chore: Start removing RotateWithDirection

buttplug-user-device-config-v4.json

···
+{
+  "version": {
+    "major": 4,
+    "minor": 0
+  },
+  "user_configs": {
+    "protocols": {},
+    "devices": [
+      {
+        "identifier": {
+          "protocol": "lovense",
+          "identifier": "EL",
+          "address": "PeripheralId(81b8f016-ba95-e1ae-3a71-a2e6b1d83b21)"
+        },
+        "config": {
+          "id": "5d434198-4697-4b00-985e-33788fc955d1",
+          "base_id": "bbfd764c-b419-4c13-aeb0-e753a86318ed",
+          "features": [
+            {
+              "id": "16099312-8bf8-45f7-9a37-9c56ffd972ae",
+              "base_id": "0627be5e-8553-4f20-b4cf-15f5e1896e5f",
+              "output": {
+                "vibrate": {
+                  "disabled": false
+                }
+              }
+            },
+            {
+              "id": "c82ea967-3014-49ef-8189-e7e065c4bdbf",
+              "base_id": "360d81e7-5126-4dbb-b72d-7bb60eb67400",
+              "output": {
+                "rotate": {
+                  "disabled": false
+                }
+              }
+            },
+            {
+              "id": "3ad9adee-8c32-408f-8e8c-4a275bb9421c",
+              "base_id": "50b9b31f-c2a8-459a-81fd-c54604f5184e"
+            }
+          ],
+          "user_config": {
+            "allow": false,
+            "deny": false,
+            "index": 0
+          }
+        }
+      }
+    ]
+  }
+}

crates/buttplug_client/src/device/command.rs

···
   Led(u32),
   Spray(u32),
   Position(u32),
-  RotateWithDirection(u32, bool),
   PositionWithDuration(u32, u32),
   // f64 types are old style float, will need to convert before sending
   VibrateFloat(f64),
···
   LedFloat(f64),
   SprayFloat(f64),
   PositionFloat(f64),
-  RotateWithDirectionFloat(f64, bool),
   PositionWithDurationFloat(f64, u32),
 }
 
···
       OutputType::Led => Ok(ClientDeviceOutputCommand::LedFloat(value)),
       OutputType::Spray => Ok(ClientDeviceOutputCommand::SprayFloat(value)),
       OutputType::Position => Ok(ClientDeviceOutputCommand::PositionFloat(value)),
-      _ => Err(ButtplugClientError::ButtplugOutputCommandConversionError("Cannot use PositionWithDuration or RotateWithDirection with this method".to_owned()))
+      _ => Err(ButtplugClientError::ButtplugOutputCommandConversionError("Cannot use PositionWithDuration with this method".to_owned()))
     }
   }
 }
···
       ClientDeviceOutputCommand::PositionWithDuration(_, _)
       | ClientDeviceOutputCommand::PositionWithDurationFloat(_, _) => {
         OutputType::PositionWithDuration
-      }
-      ClientDeviceOutputCommand::RotateWithDirection(_, _)
-      | ClientDeviceOutputCommand::RotateWithDirectionFloat(_, _) => {
-        OutputType::RotateWithDirection
       }
     }
   }

crates/buttplug_client/src/device/feature.rs

···
     OutputCmdV4,
     OutputCommand,
     OutputPositionWithDuration,
-    OutputRotateWithDirection,
     OutputType,
     OutputValue,
   },
···
   fn check_step_value(
     &self,
     feature_output: &dyn DeviceFeatureOutputLimits,
-    steps: u32,
-  ) -> Result<u32, ButtplugClientError> {
-    if feature_output.step_limit().contains(&(steps as i32)) {
+    steps: i32,
+  ) -> Result<i32, ButtplugClientError> {
+    if feature_output.step_limit().contains(&(steps)) {
       Ok(steps)
     } else {
       Err(ButtplugClientError::ButtplugOutputCommandConversionError(
···
     &self,
     feature_output: &dyn DeviceFeatureOutputLimits,
     float_amt: f64,
-  ) -> Result<u32, ButtplugClientError> {
+  ) -> Result<i32, ButtplugClientError> {
     if !(0.0f64..=1.0f64).contains(&float_amt) {
       Err(ButtplugClientError::ButtplugOutputCommandConversionError(
         "Float values must be between 0.0 and 1.0".to_owned(),
       ))
     } else {
-      Ok((float_amt * feature_output.step_count() as f64).ceil() as u32)
+      Ok((float_amt * feature_output.step_count() as f64).ceil() as i32)
     }
   }
 
···
       }
       ClientDeviceOutputCommand::PositionWithDurationFloat(v, d) => {
         OutputCommand::PositionWithDuration(OutputPositionWithDuration::new(
-          self.convert_float_value(output, *v)?,
-          *d,
-        ))
-      }
-      ClientDeviceOutputCommand::RotateWithDirectionFloat(v, d) => {
-        OutputCommand::RotateWithDirection(OutputRotateWithDirection::new(
-          self.convert_float_value(output, *v)?,
+          self.convert_float_value(output, *v)? as u32,
           *d,
         ))
       }
       ClientDeviceOutputCommand::Vibrate(v) => {
-        OutputCommand::Vibrate(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Vibrate(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::Oscillate(v) => {
-        OutputCommand::Oscillate(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Oscillate(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::Rotate(v) => {
-        OutputCommand::Rotate(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Rotate(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::Constrict(v) => {
-        OutputCommand::Constrict(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Constrict(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::Heater(v) => {
-        OutputCommand::Heater(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Heater(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::Led(v) => {
-        OutputCommand::Led(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Led(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::Spray(v) => {
-        OutputCommand::Spray(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Spray(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::Position(v) => {
-        OutputCommand::Position(OutputValue::new(self.check_step_value(output, *v)?))
+        OutputCommand::Position(OutputValue::new(self.check_step_value(output, *v as i32)?))
       }
       ClientDeviceOutputCommand::PositionWithDuration(v, d) => OutputCommand::PositionWithDuration(
-        OutputPositionWithDuration::new(self.check_step_value(output, *v)?, *d),
-      ),
-      ClientDeviceOutputCommand::RotateWithDirection(v, d) => OutputCommand::RotateWithDirection(
-        OutputRotateWithDirection::new(self.check_step_value(output, *v)?, *d),
+        OutputPositionWithDuration::new(self.check_step_value(output, *v as i32)? as u32, *d),
       ),
     };
     Ok(OutputCmdV4::new(
···
       }
       ClientDeviceCommandValue::Float(f) => {
         ClientDeviceOutputCommand::PositionWithDurationFloat(f, duration_in_ms)
-      }
-    })
-  }
-
-  pub fn rotate_with_direction(
-    &self,
-    level: impl Into<ClientDeviceCommandValue>,
-    clockwise: bool,
-  ) -> ButtplugClientResultFuture {
-    let val = level.into();
-    self.send_command(&match val {
-      ClientDeviceCommandValue::Int(v) => {
-        ClientDeviceOutputCommand::RotateWithDirection(v, clockwise)
-      }
-      ClientDeviceCommandValue::Float(f) => {
-        ClientDeviceOutputCommand::RotateWithDirectionFloat(f, clockwise)
       }
     })
   }

crates/buttplug_core/src/errors.rs

···
   DeviceScanningAlreadyStopped,
   /// Device permission error: {0}
   DevicePermissionError(String),
+  /// Device command does not take negative numbers
+  DeviceCommandSignError,
   /// {0}
   ProtocolAttributesNotFound(String),
   /// Protocol {0} not implemented in library

crates/buttplug_core/src/message/device_feature.rs

···
   Unknown,
   #[serde(alias = "vibrate")]
   Vibrate,
-  // Single Direction Rotation Speed
   #[serde(alias = "rotate")]
   Rotate,
-  // Two Direction Rotation Speed
-  #[serde(alias = "rotate_with_direction")]
-  RotateWithDirection,
   #[serde(alias = "oscillate")]
   Oscillate,
   #[serde(alias = "constrict")]
···
   #[serde(skip_serializing_if = "Option::is_none")]
   rotate: Option<DeviceFeatureOutputValueProperties>,
   #[serde(skip_serializing_if = "Option::is_none")]
-  rotate_with_direction: Option<DeviceFeatureOutputValueProperties>,
-  #[serde(skip_serializing_if = "Option::is_none")]
   oscillate: Option<DeviceFeatureOutputValueProperties>,
   #[serde(skip_serializing_if = "Option::is_none")]
   constrict: Option<DeviceFeatureOutputValueProperties>,
···
       OutputType::Position => self.position.is_some(),
       OutputType::PositionWithDuration => self.position_with_duration.is_some(),
       OutputType::Rotate => self.rotate.is_some(),
-      OutputType::RotateWithDirection => self.rotate_with_direction.is_some(),
       OutputType::Spray => self.spray.is_some(),
       OutputType::Unknown => false,
       OutputType::Vibrate => self.vibrate.is_some(),
···
         .map(|x| x as &dyn DeviceFeatureOutputLimits),
       OutputType::Rotate => self
         .rotate()
-        .as_ref()
-        .map(|x| x as &dyn DeviceFeatureOutputLimits),
-      OutputType::RotateWithDirection => self
-        .rotate_with_direction()
         .as_ref()
         .map(|x| x as &dyn DeviceFeatureOutputLimits),
       OutputType::Spray => self

crates/buttplug_core/src/message/v4/mod.rs

···
     OutputCmdV4,
     OutputCommand,
     OutputPositionWithDuration,
-    OutputRotateWithDirection,
     OutputValue,
   },
   request_server_info::RequestServerInfoV4,

crates/buttplug_core/src/message/v4/output_cmd.rs

···
 #[getset(get_copy = "pub")]
 pub struct OutputValue {
   #[serde(rename = "Value")]
-  value: u32,
+  value: i32,
 }
 
 impl OutputValue {
-  pub fn new(value: u32) -> Self {
+  pub fn new(value: i32) -> Self {
     Self { value }
   }
 }
···
   }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, CopyGetters)]
-#[getset(get_copy = "pub")]
-pub struct OutputRotateWithDirection {
-  #[serde(rename = "Speed")]
-  speed: u32,
-  #[serde(rename = "Clockwise")]
-  clockwise: bool,
-}
-
-impl OutputRotateWithDirection {
-  pub fn new(speed: u32, clockwise: bool) -> Self {
-    Self { speed, clockwise }
-  }
-}
-
 #[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum OutputCommand {
   Vibrate(OutputValue),
   // Single Direction Rotation Speed
   Rotate(OutputValue),
-  // Two Direction Rotation Speed
-  RotateWithDirection(OutputRotateWithDirection),
   Oscillate(OutputValue),
   Constrict(OutputValue),
   Spray(OutputValue),
···
 }
 
 impl OutputCommand {
-  pub fn value(&self) -> u32 {
+  pub fn value(&self) -> i32 {
     match self {
       OutputCommand::Constrict(x)
       | OutputCommand::Spray(x)
···
       | OutputCommand::Position(x)
       | OutputCommand::Rotate(x)
       | OutputCommand::Vibrate(x) => x.value(),
-      OutputCommand::RotateWithDirection(x) => x.speed(),
-      OutputCommand::PositionWithDuration(x) => x.position(),
+      OutputCommand::PositionWithDuration(x) => x.position() as i32,
     }
   }
 
-  pub fn set_value(&mut self, value: u32) {
+  pub fn set_value(&mut self, value: i32) {
     match self {
       OutputCommand::Constrict(x)
       | OutputCommand::Spray(x)
···
       | OutputCommand::Position(x)
       | OutputCommand::Rotate(x)
       | OutputCommand::Vibrate(x) => x.value = value,
-      OutputCommand::RotateWithDirection(x) => x.speed = value,
-      OutputCommand::PositionWithDuration(x) => x.position = value,
+      OutputCommand::PositionWithDuration(x) => x.position = value as u32,
     }
   }
 
···
     match self {
       Self::Vibrate(_) => OutputType::Vibrate,
       Self::Rotate(_) => OutputType::Rotate,
-      Self::RotateWithDirection(_) => OutputType::RotateWithDirection,
       Self::Oscillate(_) => OutputType::Oscillate,
       Self::Constrict(_) => OutputType::Constrict,
       Self::Spray(_) => OutputType::Spray,
···
     }
   }
 
-  pub fn from_output_type(output_type: OutputType, value: u32) -> Result<Self, ButtplugError> {
+  pub fn from_output_type(output_type: OutputType, value: i32) -> Result<Self, ButtplugError> {
     match output_type {
       OutputType::Constrict => Ok(Self::Constrict(OutputValue::new(value))),
       OutputType::Heater => Ok(Self::Heater(OutputValue::new(value))),

crates/buttplug_server/src/device/protocol.rs

···
     let output_command = cmd.output_command();
     match output_command {
       OutputCommand::Constrict(x) => {
-        self.handle_output_constrict_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
+        self.handle_output_constrict_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Spray(x) => {
-        self.handle_output_spray_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
+        self.handle_output_spray_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Oscillate(x) => {
-        self.handle_output_oscillate_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
+        self.handle_output_oscillate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Rotate(x) => {
         self.handle_output_rotate_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
       }
       OutputCommand::Vibrate(x) => {
-        self.handle_output_vibrate_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
+        self.handle_output_vibrate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Position(x) => {
-        self.handle_output_position_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
+        self.handle_output_position_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Heater(x) => {
-        self.handle_output_heater_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
+        self.handle_output_heater_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Led(x) => {
-        self.handle_output_led_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
+        self.handle_output_led_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::PositionWithDuration(x) => self.handle_position_with_duration_cmd(
         cmd.feature_index(),
         cmd.feature_id(),
         x.position(),
         x.duration(),
-      ),
-      OutputCommand::RotateWithDirection(x) => self.handle_rotation_with_direction_cmd(
-        cmd.feature_index(),
-        cmd.feature_id(),
-        x.speed(),
-        x.clockwise(),
       ),
     }
   }
···
     &self,
     _feature_index: u32,
     _feature_id: Uuid,
-    _speed: u32,
+    _speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     self.command_unimplemented("OutputCmd (Rotate Actuator)")
   }

crates/buttplug_server/src/device/protocol_impl/cowgirl.rs

···
     &self,
     _feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     self.speeds[1].store(speed as u8, Ordering::Relaxed);
     Ok(self.hardware_commands())

crates/buttplug_server/src/device/protocol_impl/joyhub/joyhub.rs

···
     &self,
     feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.form_hardware_command(feature_index, speed)
+    self.form_hardware_command(feature_index, speed as u32)
   }
 
   fn handle_output_oscillate_cmd(

crates/buttplug_server/src/device/protocol_impl/joyhub/joyhub_v2.rs

···
     &self,
     feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.form_hardware_command(feature_index, speed)
+    self.form_hardware_command(feature_index, speed as u32)
   }
 
   fn handle_output_oscillate_cmd(

crates/buttplug_server/src/device/protocol_impl/joyhub/joyhub_v4.rs

···
     &self,
     feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.form_hardware_command(feature_index, speed)
+    self.form_hardware_command(feature_index, speed as u32)
   }
 
   fn handle_output_oscillate_cmd(

crates/buttplug_server/src/device/protocol_impl/joyhub/joyhub_v5.rs

···
     &self,
     feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.form_hardware_command(feature_index, speed)
+    self.form_hardware_command(feature_index, speed as u32)
   }
 
   fn handle_output_oscillate_cmd(

crates/buttplug_server/src/device/protocol_impl/joyhub/joyhub_v6.rs

···
     &self,
     feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.form_hardware_command(feature_index, speed)
+    self.form_hardware_command(feature_index, speed as u32)
   }
 
   fn handle_output_oscillate_cmd(

crates/buttplug_server/src/device/protocol_impl/kizuna.rs

···
     &self,
     _feature_index: u32,
     feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     Ok(vec![
       HardwareWriteCmd::new(

crates/buttplug_server/src/device/protocol_impl/lelo_harmony.rs

···
     &self,
     feature_index: u32,
     feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.handle_input_cmd(feature_index, feature_id, speed)
+    self.handle_input_cmd(feature_index, feature_id, speed as u32)
   }
 
   fn handle_output_vibrate_cmd(

crates/buttplug_server/src/device/protocol_impl/lovense/lovense_multi_actuator.rs

···
     feature_id: Uuid,
     speed: u32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
+    debug!("Lovense multi-actuator command: {}", format!("Vibrate{}:{};", feature_index + 1, speed));
     let lovense_cmd = format!("Vibrate{}:{};", feature_index + 1, speed)
       .as_bytes()
       .to_vec();

crates/buttplug_server/src/device/protocol_impl/lovense/lovense_rotate_vibrator.rs

···
     &self,
     _feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    form_rotate_with_direction_command(speed, false)
+    form_rotate_with_direction_command(speed.abs() as u32, speed < 0)
   }
 
   fn handle_rotation_with_direction_cmd(

crates/buttplug_server/src/device/protocol_impl/lovense/mod.rs

···
         .filter(|x| {
           x.output()
             .as_ref()
-            .is_some_and(|x| x.contains(OutputType::RotateWithDirection))
+            .is_some_and(|x| x.contains(OutputType::Rotate))
         })
         .count()
         == 1;

crates/buttplug_server/src/device/protocol_impl/luvmazer.rs

···
     &self,
     _feature_index: u32,
     feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     Ok(vec![
       HardwareWriteCmd::new(

crates/buttplug_server/src/device/protocol_impl/metaxsire.rs

···
     &self,
     feature_index: u32,
     _feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.form_command(feature_index, speed)
+    self.form_command(feature_index, speed as u32)
   }
 
   fn handle_output_constrict_cmd(

crates/buttplug_server/src/device/protocol_impl/metaxsire_v3.rs

···
     &self,
     feature_index: u32,
     feature_id: uuid::Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    self.form_command(feature_index, feature_id, speed)
+    self.form_command(feature_index, feature_id, speed as u32)
   }
 }

crates/buttplug_server/src/device/protocol_impl/sakuraneko.rs

···
     &self,
     _feature_index: u32,
     feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     Ok(vec![
       HardwareWriteCmd::new(

crates/buttplug_server/src/device/protocol_impl/svakom/svakom_v3.rs

···
     &self,
     _feature_index: u32,
     feature_id: Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     Ok(vec![
       HardwareWriteCmd::new(

crates/buttplug_server/src/device/protocol_impl/tryfun.rs

···
     &self,
     _feature_index: u32,
     feature_id: uuid::Uuid,
-    speed: u32,
+    speed: i32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     let mut sum: u8 = 0xff;
     let mut data = vec![0xAA, 0x02, 0x08, speed as u8];

crates/buttplug_server/src/device/server_device.rs

···
     DeviceMessageInfoV4,
     InputCommandType,
     InputType,
-    OutputRotateWithDirection,
     OutputType,
     OutputValue,
   },
···
             }
             OutputType::Rotate => {
               stop_cmd(message::OutputCommand::Rotate(OutputValue::new(0)));
-              break;
-            }
-            OutputType::RotateWithDirection => {
-              stop_cmd(message::OutputCommand::RotateWithDirection(
-                OutputRotateWithDirection::new(0, true),
-              ));
               break;
             }
             OutputType::Vibrate => {

crates/buttplug_server/src/message/v3/client_device_message_attributes.rs

···
   v2::{ClientDeviceMessageAttributesV2, GenericDeviceMessageAttributesV2},
 };
 use buttplug_core::message::{
-  DeviceFeature,
-  DeviceFeatureOutputValueProperties,
-  InputCommandType,
-  InputType,
-  OutputType,
+  DeviceFeature, DeviceFeatureOutputLimits, DeviceFeatureOutputValueProperties, InputCommandType, InputType, OutputType
 };
 use getset::{Getters, MutGetters, Setters};
 use serde::{Deserialize, Serialize, Serializer, ser::SerializeSeq};
···
       .flat_map(|feature| {
         let mut actuator_vec = vec![];
         if let Some(output_map) = feature.output()
-          && let Some(actuator) = output_map.rotate_with_direction() {
+          && let Some(actuator) = output_map.rotate() 
+          && *actuator.value().start() < 0 {
             let actuator_type = OutputType::Rotate;
             let attrs = ClientGenericDeviceMessageAttributesV3 {
               feature_descriptor: feature.description().to_owned(),

crates/buttplug_server/src/message/v3/server_device_message_attributes.rs

···
       .flat_map(|feature| {
         let mut actuator_vec = vec![];
         if let Some(output_map) = feature.output()
-          && let Some(actuator) = output_map.rotate_with_direction() {
+          && let Some(actuator) = output_map.rotate() 
+          && *actuator.value().base().start() < 0 {
             let actuator_type = OutputType::Rotate;
             let step_count = actuator.value().step_count();
             let attrs = ServerGenericDeviceMessageAttributesV3 {

crates/buttplug_server/src/message/v4/checked_output_cmd.rs

···
       let value = cmd.command().value();
       let new_value = output_map
         .calculate_from_value(output_type, value as i32)
-        .map_err(|_| ButtplugDeviceError::DeviceStepRangeError(0, value))?;
+        .map_err(|_| ButtplugDeviceError::DeviceStepRangeError(0, value.abs() as u32))?;
       let mut new_command = cmd.command();
-      new_command.set_value(new_value as u32);
+      new_command.set_value(new_value);
       // We can't make a private trait impl to turn a ValueCmd into a CheckedValueCmd, and this
       // is all about security, so we just copy. Silly, but it works for our needs in terms of
       // making this a barrier.

crates/buttplug_server/src/message/v4/checked_output_vec_cmd.rs

···
     ButtplugMessageValidator,
     OutputCommand,
     OutputPositionWithDuration,
-    OutputRotateWithDirection,
     OutputType,
     OutputValue,
   },
···
             |e: buttplug_server_device_config::ButtplugDeviceConfigError| {
               ButtplugMessageError::InvalidMessageContents(e.to_string())
             },
-          )? as u32,
+          )?,
         )),
       ))
     }
···
         OutputCommand::Vibrate(OutputValue::new(
           actuator
             .calculate_scaled_float(vibrate_cmd.speed())
-            .map_err(|e| ButtplugMessageError::InvalidMessageContents(e.to_string()))?
-            as u32,
+            .map_err(|e| ButtplugMessageError::InvalidMessageContents(e.to_string()))?,
         )),
       ))
     }
···
         msg.device_index(),
         idx,
         feature.feature.id(),
-        OutputCommand::from_output_type(cmd.actuator_type(), output_value as u32).unwrap(),
+        OutputCommand::from_output_type(cmd.actuator_type(), output_value).unwrap(),
       ));
     }
 
···
         .ok_or(ButtplugError::from(
           ButtplugDeviceError::DeviceNoActuatorError("RotateCmdV1".to_owned()),
         ))?
-        .rotate_with_direction()
+        .rotate()
         .as_ref()
         .ok_or(ButtplugError::from(
           ButtplugDeviceError::DeviceNoActuatorError("RotateCmdV1".to_owned()),
···
         msg.device_index(),
         idx,
         feature.feature.id(),
-        OutputCommand::RotateWithDirection(OutputRotateWithDirection::new(
+        OutputCommand::Rotate(OutputValue::new(
           actuator.calculate_scaled_float(cmd.speed()).map_err(|_| {
             ButtplugError::from(ButtplugMessageError::InvalidMessageContents(
               "Position should be 0.0 < x < 1.0".to_owned(),
             ))
-          })? as u32,
-          cmd.clockwise(),
+          })? as i32 * (if cmd.clockwise() { 1 } else { -1 })
         )),
       ));
     }

crates/buttplug_server_device_config/build-config/buttplug-device-config-v4.json

···
 {
   "version": {
     "major": 4,
-    "minor": 67
+    "minor": 69
   },
   "protocols": {
     "activejoy": {
···
             {
               "id": "515e07e2-a6e6-4ac0-a4b0-512504311260",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -20,
                     20
···
             {
               "id": "360d81e7-5126-4dbb-b72d-7bb60eb67400",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -20,
                     20
···
             {
               "id": "af885c72-ce2b-47d5-87be-3847f24d18a5",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -20,
                     20
···
             {
               "id": "d49001e8-5f6b-43ac-9cc7-7e68fab7c323",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -20,
                     20
···
           {
             "id": "683b450d-bb1a-4fca-b61a-83f8b56086fa",
             "output": {
-              "rotate_with_direction": {
+              "rotate": {
                 "value": [
                   -255,
                   255
···
           {
             "id": "fabe3961-dc17-4f32-856f-13880c0a29a3",
             "output": {
-              "rotate_with_direction": {
+              "rotate": {
                 "value": [
                   -2,
                   2
···
           {
             "id": "b7495351-9101-448a-94c4-4598cf541dca",
             "output": {
-              "rotate_with_direction": {
+              "rotate": {
                 "value": [
                   -6,
                   6
···
           {
             "id": "26402ebe-7ee0-4c7d-ae40-205ec4f3a1b0",
             "output": {
-              "rotate_with_direction": {
+              "rotate": {
                 "value": [
                   -100,
                   100
···
           {
             "id": "1d1b4dea-ab29-4426-a9f4-dda2c594eefb",
             "output": {
-              "rotate_with_direction": {
+              "rotate": {
                 "value": [
                   -10,
                   10
···
             {
               "id": "8e249d53-8d80-4f42-bc40-e6edb7779e92",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -99,
                     99
···
             {
               "id": "2d8d1443-c394-4df4-b9bb-1659d8323b45",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -99,
                     99
···
             {
               "id": "a1632ce4-314f-481d-9ae2-2a11a0c4caa4",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -99,
                     99
···
             {
               "id": "4b09a02d-9a4a-4c8b-8340-8e6ca3cecfc2",
               "output": {
-                "rotate_with_direction": {
+                "rotate": {
                   "value": [
                     -99,
                     99

crates/buttplug_server_device_config/device-config-v4/buttplug-device-config-schema-v4.json

···
           "output": {
             "type": "object",
             "patternProperties": {
-              "^(vibrate|rotate|oscillate|constrict|spray|position|rotate_with_direction|heater|led)$": {
+              "^(vibrate|rotate|oscillate|constrict|spray|position|heater|led)$": {
                 "type": "object",
                 "properties": {
                   "value": {
···
           "output": {
             "type": "object",
             "patternProperties": {
-              "^(vibrate|rotate|oscillate|constrict|spray|rotate_with_direction|heater|led)$": {
+              "^(vibrate|rotate|oscillate|constrict|spray|heater|led)$": {
                 "type": "object",
                 "properties": {
                   "value": {

crates/buttplug_server_device_config/device-config-v4/protocols/lovense-connect-service.yml

···
               - 20
       - id: af885c72-ce2b-47d5-87be-3847f24d18a5
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -20
               - 20
···
               - 20
       - id: d49001e8-5f6b-43ac-9cc7-7e68fab7c323
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -20
               - 20

crates/buttplug_server_device_config/device-config-v4/protocols/lovense.yml

···
               - 20
       - id: 515e07e2-a6e6-4ac0-a4b0-512504311260
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -20
               - 20
···
               - 20
       - id: 360d81e7-5126-4dbb-b72d-7bb60eb67400
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -20
               - 20

crates/buttplug_server_device_config/device-config-v4/protocols/motorbunny.yml

···
             - 255
     - id: 683b450d-bb1a-4fca-b61a-83f8b56086fa
       output:
-        rotate_with_direction:
+        rotate:
           value:
             - -255
             - 255

crates/buttplug_server_device_config/device-config-v4/protocols/nexus-revo.yml

···
             - 10
     - id: fabe3961-dc17-4f32-856f-13880c0a29a3
       output:
-        rotate_with_direction:
+        rotate:
           value:
             - -2
             - 2

crates/buttplug_server_device_config/device-config-v4/protocols/synchro.yml

···
   features:
     - id: b7495351-9101-448a-94c4-4598cf541dca
       output:
-        rotate_with_direction:
+        rotate:
           value:
             - -6
             - 6

crates/buttplug_server_device_config/device-config-v4/protocols/tryfun-meta2.yml

···
             - 100
     - id: 26402ebe-7ee0-4c7d-ae40-205ec4f3a1b0
       output:
-        rotate_with_direction:
+        rotate:
           value:
             - -100
             - 100

crates/buttplug_server_device_config/device-config-v4/protocols/vorze-cyclone-x.yml

···
   features:
     - id: 1d1b4dea-ab29-4426-a9f4-dda2c594eefb
       output:
-        rotate_with_direction:
+        rotate:
           value:
             - -10
             - 10

crates/buttplug_server_device_config/device-config-v4/protocols/vorze-sa.yml

···
     features:
       - id: 8e249d53-8d80-4f42-bc40-e6edb7779e92
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -99
               - 99
···
     features:
       - id: 2d8d1443-c394-4df4-b9bb-1659d8323b45
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -99
               - 99
···
     features:
       - id: a1632ce4-314f-481d-9ae2-2a11a0c4caa4
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -99
               - 99
       - id: 4b09a02d-9a4a-4c8b-8340-8e6ca3cecfc2
         output:
-          rotate_with_direction:
+          rotate:
             value:
               - -99
               - 99

crates/buttplug_server_device_config/device-config-v4/version.yaml

···
 version:
   major: 4
-  minor: 67
+  minor: 69

crates/buttplug_server_device_config/src/device_config_file/feature.rs

···
   #[serde(skip_serializing_if = "Option::is_none")]
   rotate: Option<BaseDeviceFeatureOutputValueProperties>,
   #[serde(skip_serializing_if = "Option::is_none")]
-  rotate_with_direction: Option<BaseDeviceFeatureOutputValueProperties>,
-  #[serde(skip_serializing_if = "Option::is_none")]
   oscillate: Option<BaseDeviceFeatureOutputValueProperties>,
   #[serde(skip_serializing_if = "Option::is_none")]
   constrict: Option<BaseDeviceFeatureOutputValueProperties>,
···
     }
     if let Some(rotate) = val.rotate {
       output.set_rotate(Some(rotate.into()));
-    }
-    if let Some(rotate_with_direction) = val.rotate_with_direction {
-      output.set_rotate_with_direction(Some(rotate_with_direction.into()));
     }
     if let Some(oscillate) = val.oscillate {
       output.set_oscillate(Some(oscillate.into()));
···
   #[serde(skip_serializing_if = "Option::is_none")]
   rotate: Option<UserDeviceFeatureOutputValueProperties>,
   #[serde(skip_serializing_if = "Option::is_none")]
-  rotate_with_direction: Option<UserDeviceFeatureOutputValueProperties>,
-  #[serde(skip_serializing_if = "Option::is_none")]
   oscillate: Option<UserDeviceFeatureOutputValueProperties>,
   #[serde(skip_serializing_if = "Option::is_none")]
   constrict: Option<UserDeviceFeatureOutputValueProperties>,
···
     base_output: &ServerDeviceFeatureOutput,
   ) -> Result<ServerDeviceFeatureOutput, ButtplugDeviceConfigError> {
     let mut output = ServerDeviceFeatureOutput::default();
+    // TODO Flip logic and output errors if user has something base doesn't, or vice versa.
     if let Some(base_vibrate) = base_output.vibrate() {
       if let Some(user_vibrate) = &self.vibrate {
         output.set_vibrate(Some(user_vibrate.with_base_properties(base_vibrate)?));
···
     Self {
       vibrate: value.vibrate().as_ref().map(|x| x.into()),
       rotate: value.rotate().as_ref().map(|x| x.into()),
-      rotate_with_direction: value.rotate_with_direction().as_ref().map(|x| x.into()),
       oscillate: value.oscillate().as_ref().map(|x| x.into()),
       constrict: value.constrict().as_ref().map(|x| x.into()),
       heater: value.heater().as_ref().map(|x| x.into()),

crates/buttplug_server_device_config/src/server_device_feature.rs

···
 pub struct ServerDeviceFeatureOutput {
   vibrate: Option<ServerDeviceFeatureOutputValueProperties>,
   rotate: Option<ServerDeviceFeatureOutputValueProperties>,
-  rotate_with_direction: Option<ServerDeviceFeatureOutputValueProperties>,
   oscillate: Option<ServerDeviceFeatureOutputValueProperties>,
   constrict: Option<ServerDeviceFeatureOutputValueProperties>,
   heater: Option<ServerDeviceFeatureOutputValueProperties>,
···
       OutputType::Position => self.position.is_some(),
       OutputType::PositionWithDuration => self.position_with_duration.is_some(),
       OutputType::Rotate => self.rotate.is_some(),
-      OutputType::RotateWithDirection => self.rotate.is_some(),
       OutputType::Spray => self.spray.is_some(),
       OutputType::Unknown => false,
       OutputType::Vibrate => self.vibrate.is_some(),
···
       .rotate
       .is_some()
       .then(|| types.push(OutputType::Rotate));
-    self
-      .rotate_with_direction
-      .is_some()
-      .then(|| types.push(OutputType::RotateWithDirection));
     self.spray.is_some().then(|| types.push(OutputType::Spray));
     self
       .vibrate
···
         Err(ButtplugDeviceConfigError::InvalidOutput(output_type)),
         |x| x.calculate_scaled_value(value),
       ),
-      OutputType::RotateWithDirection => self.rotate_with_direction.as_ref().map_or(
-        Err(ButtplugDeviceConfigError::InvalidOutput(output_type)),
-        |x| x.calculate_scaled_value(value),
-      ),
       OutputType::Spray => self.spray.as_ref().map_or(
         Err(ButtplugDeviceConfigError::InvalidOutput(output_type)),
         |x| x.calculate_scaled_value(value),
···
         Err(ButtplugDeviceConfigError::InvalidOutput(output_type)),
         |x| x.calculate_scaled_float(value),
       ),
-      OutputType::RotateWithDirection => self.rotate_with_direction.as_ref().map_or(
-        Err(ButtplugDeviceConfigError::InvalidOutput(output_type)),
-        |x| x.calculate_scaled_float(value),
-      ),
       OutputType::Spray => self.spray.as_ref().map_or(
         Err(ButtplugDeviceConfigError::InvalidOutput(output_type)),
         |x| x.calculate_scaled_float(value),
···
     let mut builder = DeviceFeatureOutputBuilder::default();
     val.vibrate.as_ref().map(|x| builder.vibrate(x.into()));
     val.rotate.as_ref().map(|x| builder.rotate(x.into()));
-    val
-      .rotate_with_direction
-      .as_ref()
-      .map(|x| builder.rotate_with_direction(x.into()));
     val.oscillate.as_ref().map(|x| builder.oscillate(x.into()));
     val.constrict.as_ref().map(|x| builder.constrict(x.into()));
     val.heater.as_ref().map(|x| builder.heater(x.into()));

crates/examples/src/bin/device_tester.rs

···
   DeviceFeature,
   DeviceFeatureOutput,
   OutputCommand,
-  OutputRotateWithDirection,
   OutputType,
   OutputValue,
 };