refactor(attribute): remove Operand enum and related logic

Author: wu-vincent

endstone/attribute/__init__.pyi

@@ -33,19 +33,7 @@ class AttributeModifier:
     """
     Represents an attribute modifier.
     """
-    def __init__(self, name: str, amount: float, operation: Operation, operand: Operand = Operand.VALUE) -> None: ...
-    class Operand(enum.Enum):
-        """
-        Value on which operation to be applied.
-        """
-
-        VALUE = 0
-        MAX_VALUE = 1
-        MIN_VALUE = 2
-
-    VALUE = Operand.VALUE
-    MAX_VALUE = Operand.MAX_VALUE
-    MIN_VALUE = Operand.MIN_VALUE
+    def __init__(self, name: str, amount: float, operation: Operation) -> None: ...
     class Operation(enum.Enum):
         """
         Operation to be applied.
@@ -86,12 +74,6 @@ class AttributeModifier:
         """
         ...
     @property
-    def operand(self) -> Operand:
-        """
-        Get the operand this modifier will apply.
-        """
-        ...
-    @property
     def operation(self) -> Operation:
         """
         Get the operation this modifier will apply.

include/endstone/attribute/attribute_modifier.h

@@ -23,15 +23,6 @@ namespace endstone {
  */
 class AttributeModifier {
 public:
-    /**
-     * @brief Value on which operation to be applied.
-     */
-    enum class Operand {
-        Value,
-        MaxValue,
-        MinValue,
-    };
-
     /**
      * @brief Operation to be applied.
      */
@@ -55,13 +46,13 @@ class AttributeModifier {
         Multiply
     };
 
-    AttributeModifier(std::string name, float amount, Operation operation, Operand operand = Operand::Value)
-        : name_(std::move(name)), amount_(amount), operand_(operand), operation_(operation)
+    AttributeModifier(std::string name, float amount, Operation operation)
+        : name_(std::move(name)), amount_(amount), operation_(operation)
     {
     }
 
-    AttributeModifier(std::string name, UUID uuid, float amount, Operation operation, Operand operand = Operand::Value)
-        : name_(std::move(name)), uuid_(uuid), amount_(amount), operand_(operand), operation_(operation)
+    AttributeModifier(std::string name, UUID uuid, float amount, Operation operation)
+        : name_(std::move(name)), uuid_(uuid), amount_(amount), operation_(operation)
     {
     }
 
@@ -86,13 +77,6 @@ class AttributeModifier {
      */
     [[nodiscard]] float getAmount() const { return amount_; }
 
-    /**
-     * @brief Get the operand this modifier will apply.
-     *
-     * @return operand
-     */
-    [[nodiscard]] Operand getOperand() const { return operand_; }
-
     /**
      * @brief Get the operation this modifier will apply.
      *
@@ -104,7 +88,6 @@ class AttributeModifier {
     std::string name_;
     UUID uuid_;
     float amount_;
-    Operand operand_;
     Operation operation_;
 };
 }  // namespace endstone

src/endstone/python/attribute.cpp

@@ -65,14 +65,6 @@ void init_attribute(py::module_ &m)
 
     auto modifier = py::class_<AttributeModifier>(m, "AttributeModifier", "Represents an attribute modifier.");
 
-    py::native_enum<AttributeModifier::Operand>(modifier, "Operand", "enum.Enum",
-                                                "Value on which operation to be applied.")
-        .value("VALUE", AttributeModifier::Operand::Value)
-        .value("MAX_VALUE", AttributeModifier::Operand::MaxValue)
-        .value("MIN_VALUE", AttributeModifier::Operand::MinValue)
-        .export_values()
-        .finalize();
-
     py::native_enum<AttributeModifier::Operation>(modifier, "Operation", "enum.Enum", "Operation to be applied.")
         .value("ADD", AttributeModifier::Operation::Add, "Adds (or subtracts) the specified amount to the base value.")
         .value("MULTIPLY_BASE", AttributeModifier::Operation::MultiplyBase,
@@ -85,13 +77,12 @@ void init_attribute(py::module_ &m)
         .finalize();
 
     modifier
-        .def(py::init<std::string, float, AttributeModifier::Operation, AttributeModifier::Operand>(), py::arg("name"),
-             py::arg("amount"), py::arg("operation"), py::arg("operand") = AttributeModifier::Operand::Value)
+        .def(py::init<std::string, float, AttributeModifier::Operation>(), py::arg("name"), py::arg("amount"),
+             py::arg("operation"))
         .def_property_readonly("unique_id", &AttributeModifier::getUniqueId, "Get the unique ID for this modifier.")
         .def_property_readonly("name", &AttributeModifier::getName, "Get the name of this modifier.")
         .def_property_readonly("amount", &AttributeModifier::getAmount,
                                "Get the amount by which this modifier will apply the operation.")
-        .def_property_readonly("operand", &AttributeModifier::getOperand, "Get the operand this modifier will apply.")
         .def_property_readonly("operation", &AttributeModifier::getOperation,
                                "Get the operation this modifier will apply.");