Correct ServerActiveObject's virtual getArmorGroups() to be const.

[dragonfireclient.git] / src / craftdef.cpp

diff --git a/src/craftdef.cpp b/src/craftdef.cpp
index 04e418e29436d6bf734d255a7b8974f05f63c718..24b7437cbe7ec15bfaba220fd8b31f15abaf8581 100644 (file)
--- a/src/craftdef.cpp
+++ b/src/craftdef.cpp
@@ -37,6 +37,15 @@ inline bool isGroupRecipeStr(const std::string &rec_name)
        return str_starts_with(rec_name, std::string("group:"));
 }
 
+static bool hasGroupItem(const std::vector<std::string> &recipe)
+{
+       for (const auto &item : recipe) {
+               if (isGroupRecipeStr(item))
+                       return true;
+       }
+       return false;
+}
+
 inline u64 getHashForString(const std::string &recipe_str)
 {
        /*errorstream << "Hashing craft string  \"" << recipe_str << '"';*/
@@ -320,6 +329,19 @@ std::string CraftReplacements::dump() const
        CraftDefinitionShaped
 */
 
+CraftDefinitionShaped::CraftDefinitionShaped(
+               const std::string &output_,
+               unsigned int width_,
+               const std::vector<std::string> &recipe_,
+               const CraftReplacements &replacements_):
+       output(output_), width(width_), recipe(recipe_), replacements(replacements_)
+{
+       if (hasGroupItem(recipe))
+               priority = PRIORITY_SHAPED_AND_GROUPS;
+       else
+               priority = PRIORITY_SHAPED;
+}
+
 std::string CraftDefinitionShaped::getName() const
 {
        return "shaped";
@@ -407,22 +429,6 @@ void CraftDefinitionShaped::decrementInput(CraftInput &input, std::vector<ItemSt
        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
@@ -440,6 +446,11 @@ void CraftDefinitionShaped::initHash(IGameDef *gamedef)
                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
@@ -455,6 +466,18 @@ std::string CraftDefinitionShaped::dump() const
        CraftDefinitionShapeless
 */
 
+CraftDefinitionShapeless::CraftDefinitionShapeless(
+               const std::string &output_,
+               const std::vector<std::string> &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";
@@ -527,22 +550,6 @@ void CraftDefinitionShapeless::decrementInput(CraftInput &input, std::vector<Ite
        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
@@ -558,6 +565,11 @@ void CraftDefinitionShapeless::initHash(IGameDef *gamedef)
        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
@@ -573,6 +585,12 @@ std::string CraftDefinitionShapeless::dump() const
        CraftDefinitionToolRepair
 */
 
+CraftDefinitionToolRepair::CraftDefinitionToolRepair(float additional_wear_):
+       additional_wear(additional_wear_)
+{
+       priority = PRIORITY_TOOLREPAIR;
+}
+
 static ItemStack craftToolRepair(
                const ItemStack &item1,
                const ItemStack &item2,
@@ -667,6 +685,19 @@ std::string CraftDefinitionToolRepair::dump() const
        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";
@@ -715,14 +746,6 @@ void CraftDefinitionCooking::decrementInput(CraftInput &input, std::vector<ItemS
        craftDecrementOrReplaceInput(input, output_replacements, replacements, gamedef);
 }
 
-CraftHashType CraftDefinitionCooking::getHashType() const
-{
-       if (isGroupRecipeStr(recipe_name))
-               return CRAFT_HASH_TYPE_COUNT;
-
-       return CRAFT_HASH_TYPE_ITEM_NAMES;
-}
-
 u64 CraftDefinitionCooking::getHash(CraftHashType type) const
 {
        if (type == CRAFT_HASH_TYPE_ITEM_NAMES) {
@@ -744,6 +767,11 @@ void CraftDefinitionCooking::initHash(IGameDef *gamedef)
                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 CraftDefinitionCooking::dump() const
@@ -760,6 +788,18 @@ std::string CraftDefinitionCooking::dump() const
        CraftDefinitionFuel
 */
 
+CraftDefinitionFuel::CraftDefinitionFuel(
+               const std::string &recipe_,
+               float burntime_,
+               const CraftReplacements &replacements_):
+       recipe(recipe_), burntime(burntime_), replacements(replacements_)
+{
+       if (isGroupRecipeStr(recipe_name))
+               priority = PRIORITY_SHAPELESS_AND_GROUPS;
+       else
+               priority = PRIORITY_SHAPELESS;
+}
+
 std::string CraftDefinitionFuel::getName() const
 {
        return "fuel";
@@ -808,14 +848,6 @@ void CraftDefinitionFuel::decrementInput(CraftInput &input, std::vector<ItemStac
        craftDecrementOrReplaceInput(input, output_replacements, replacements, gamedef);
 }
 
-CraftHashType CraftDefinitionFuel::getHashType() const
-{
-       if (isGroupRecipeStr(recipe_name))
-               return CRAFT_HASH_TYPE_COUNT;
-
-       return CRAFT_HASH_TYPE_ITEM_NAMES;
-}
-
 u64 CraftDefinitionFuel::getHash(CraftHashType type) const
 {
        if (type == CRAFT_HASH_TYPE_ITEM_NAMES) {
@@ -837,7 +869,13 @@ void CraftDefinitionFuel::initHash(IGameDef *gamedef)
                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);
@@ -886,7 +924,11 @@ class CCraftDefManager: public IWritableCraftDefManager
                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.
+               // 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);
 
@@ -909,7 +951,9 @@ class CCraftDefManager: public IWritableCraftDefManager
                                /*errorstream << "Checking " << input.dump() << std::endl
                                        << " against " << def->dump() << std::endl;*/
 
-                               if (def->check(input, gamedef)) {
+                               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;
@@ -920,17 +964,17 @@ class CCraftDefManager: public IWritableCraftDefManager
                                                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;
+                                       priority_best = priority;
+                                       def_best = def;
                                }
                        }
                }
-               return false;
+               if (priority_best == CraftDefinition::PRIORITY_NO_RECIPE)
+                       return false;
+               if (decrementInput)
+                       def_best->decrementInput(input, output_replacement, gamedef);
+               return true;
        }
 
        virtual std::vector<CraftDefinition*> getCraftRecipes(CraftOutput &output,