feat(skymp5-server): Recipe checks

skymp5-server/cpp/server_guest_lib/ActionListener.cpp

@@ -1,5 +1,6 @@
 #include "ActionListener.h"
 #include "AnimationSystem.h"
+#include "Condition.h"
 #include "ConsoleCommands.h"
 #include "CropRegeneration.h"
 #include "DummyMessageOutput.h"
@@ -11,15 +12,14 @@
 #include "MovementValidation.h"
 #include "MpObjectReference.h"
 #include "MsgType.h"
+#include "UpdateEquipmentMessage.h"
 #include "UserMessageOutput.h"
 #include "WorldState.h"
 #include "script_objects/EspmGameObject.h"
 #include <fmt/format.h>
 #include <spdlog/spdlog.h>
 #include <unordered_set>
 
-#include "UpdateEquipmentMessage.h"
-
 namespace {
 void SendHostStop(PartOne& partOne, Networking::UserId badHosterUserId,
                   MpObjectReference& remote)
@@ -456,8 +456,37 @@ void UseCraftRecipe(MpActor* me, const espm::COBJ* recipeUsed,
   spdlog::info("Using craft recipe with EDID {} from espm file with index {}",
                recipeUsed->GetEditorId(cache), espmIdx);
 
+  std::vector<Condition*> conditions;
+
   for (auto& condition : recipeData.conditions) {
-    // impl race, item, perk? checks
+    if (condition.IsGetItemCount()) {
+      conditions.push_back(new ItemCountCondition(
+        condition.GetDefaultData().firstParameter, condition.comparisonValue,
+        condition.GetOperator(), condition.GetFlags()));
+    } else if (condition.IsGetIsRace()) {
+      conditions.push_back(new RaceCondition(
+        condition.GetDefaultData().firstParameter, condition.comparisonValue,
+        condition.GetOperator(), condition.GetFlags()));
+    }
+  }
+
+  bool requireAnd = false;
+  for (auto& cond : conditions) {
+    if (!cond->Evaluate(me)) {
+      if (cond->GetFlags() != espm::CTDA::Flags::OR || requireAnd) {
+        spdlog::trace("UseCraftRecipe - blocked by condition: {}",
+                      cond->GetDescription());
+        delete cond;
+        return;
+      }
+    } else {
+      requireAnd = false;
+    }
+
+    if (cond->GetFlags() == espm::CTDA::Flags::ANDORDEFAULT) {
+      requireAnd = true;
+    }
+    delete cond;
   }
 
   std::vector<Inventory::Entry> entries;

skymp5-server/cpp/server_guest_lib/Condition.cpp

@@ -0,0 +1,90 @@
+#include "Condition.h"
+
+bool CalculateOperationResult(int firstArgument, int secondArgument,
+                              espm::CTDA::Operator conditionOperator)
+{
+  switch (conditionOperator) {
+    case espm::CTDA::Operator::EqualTo:
+      return firstArgument == secondArgument;
+    case espm::CTDA::Operator::NotEqualTo:
+      return firstArgument != secondArgument;
+    case espm::CTDA::Operator::GreaterThen:
+      return firstArgument > secondArgument;
+    case espm::CTDA::Operator::GreaterThenOrEqualTo:
+      return firstArgument >= secondArgument;
+    case espm::CTDA::Operator::LessThen:
+      return firstArgument < secondArgument;
+    case espm::CTDA::Operator::LessThenOrEqualTo:
+      return firstArgument <= secondArgument;
+    default:
+      return false;
+  }
+}
+
+Condition::Condition(espm::CTDA::Operator conditionOperator,
+                     espm::CTDA::Flags flags)
+  : conditionOperator(conditionOperator)
+  , flags(flags)
+{
+}
+
+espm::CTDA::Flags Condition::GetFlags() const
+{
+  return flags;
+}
+
+ItemCountCondition::ItemCountCondition(int itemId, int comparisonValue,
+                                       espm::CTDA::Operator conditionOperator,
+                                       espm::CTDA::Flags flags)
+  : Condition(conditionOperator, flags)
+  , itemId(itemId)
+  , comparisonValue(comparisonValue)
+{
+}
+
+bool ItemCountCondition::Evaluate(MpActor* actor) const
+{
+  int itemCount = actor->GetInventory().GetItemCount(itemId);
+  bool result =
+    CalculateOperationResult(itemCount, comparisonValue, conditionOperator);
+  spdlog::info("ItemCountCondition: itemId = {}, itemCount = {}, "
+               "comparisonValue = {}, operator = {}, result = {}",
+               itemId, itemCount, comparisonValue,
+               static_cast<int>(conditionOperator), result);
+  return result;
+}
+
+std::string ItemCountCondition::GetDescription() const
+{
+  return "ItemCountCondition: itemId = " + std::to_string(itemId) +
+    ", comparisonValue = " + std::to_string(comparisonValue) +
+    ", operator = " + std::to_string(static_cast<int>(conditionOperator));
+}
+
+RaceCondition::RaceCondition(int raceId, int comparisonValue,
+                             espm::CTDA::Operator conditionOperator,
+                             espm::CTDA::Flags flags)
+  : Condition(conditionOperator, flags)
+  , raceId(raceId)
+  , comparisonValue(comparisonValue)
+{
+}
+
+bool RaceCondition::Evaluate(MpActor* actor) const
+{
+  int raceEquals = actor->GetRaceId() == raceId ? 1 : 0;
+  bool result =
+    CalculateOperationResult(raceEquals, comparisonValue, conditionOperator);
+  spdlog::info("RaceCondition: raceId = {}, raceEquals = {}, "
+               "comparisonValue = {}, operator = {}, result = {}",
+               raceId, raceEquals, comparisonValue,
+               static_cast<int>(conditionOperator), result);
+  return result;
+}
+
+std::string RaceCondition::GetDescription() const
+{
+  return "RaceCondition: raceId = " + std::to_string(raceId) +
+    ", comparisonValue = " + std::to_string(comparisonValue) +
+    ", operator = " + std::to_string(static_cast<int>(conditionOperator));
+}

skymp5-server/cpp/server_guest_lib/Condition.h

@@ -0,0 +1,47 @@
+#pragma once
+#include "MpActor.h"
+#include <spdlog/spdlog.h>
+
+class Condition
+{
+protected:
+  espm::CTDA::Operator conditionOperator;
+  espm::CTDA::Flags flags;
+
+public:
+  Condition(espm::CTDA::Operator conditionOperator, espm::CTDA::Flags flags);
+  virtual bool Evaluate(MpActor* actor) const = 0;
+  virtual std::string GetDescription() const = 0;
+  espm::CTDA::Flags GetFlags() const;
+  virtual ~Condition() = default;
+};
+
+class ItemCountCondition : public Condition
+{
+  int itemId = 0;
+  int comparisonValue = 0;
+
+public:
+  ItemCountCondition(int itemId, int comparisonValue,
+                     espm::CTDA::Operator conditionOperator,
+                     espm::CTDA::Flags flags);
+
+  bool Evaluate(MpActor* actor) const override;
+
+  std::string GetDescription() const override;
+};
+
+class RaceCondition : public Condition
+{
+  int raceId = 0;
+  int comparisonValue = 0;
+
+public:
+  RaceCondition(int raceId, int comparisonValue,
+                espm::CTDA::Operator conditionOperator,
+                espm::CTDA::Flags flags);
+
+  bool Evaluate(MpActor* actor) const override;
+
+  std::string GetDescription() const override;
+};

unit/ConditionTest.cpp

@@ -0,0 +1,39 @@
+#include "Condition.h"
+#include "TestUtils.hpp"
+#include <catch2/catch_all.hpp>
+
+TEST_CASE("ItemCountCondition evaluates correctly", "[ItemCountCondition]")
+{
+  MpActor actor(LocationalData(), FormCallbacks::DoNothing());
+
+  ItemCountCondition condition(0x1, 5, espm::CTDA::Operator::EqualTo,
+                               espm::CTDA::Flags::ANDORDEFAULT);
+
+  REQUIRE(condition.Evaluate(&actor) == false);
+
+  actor.AddItem(0x1, 4);
+
+  REQUIRE(condition.Evaluate(&actor) == false);
+
+  actor.AddItem(0x1, 1);
+
+  REQUIRE(condition.Evaluate(&actor) == true);
+}
+
+TEST_CASE("RaceCondition evaluates correctly", "[RaceCondition]")
+{
+  MpActor actor(LocationalData(), FormCallbacks::DoNothing());
+  Appearance appearance;
+  appearance.raceId = 0x123;
+  actor.SetAppearance(&appearance);
+
+  RaceCondition condition(0x21, 1, espm::CTDA::Operator::EqualTo,
+                          espm::CTDA::Flags::ANDORDEFAULT);
+
+  REQUIRE(condition.Evaluate(&actor) == false);
+
+  condition = RaceCondition(0x123, 1, espm::CTDA::Operator::EqualTo,
+                            espm::CTDA::Flags::ANDORDEFAULT);
+
+  REQUIRE(condition.Evaluate(&actor) == true);
+}