Keep updating disabled actions (#583)

* Remove action consuming

* Keep updating the values of disabled actions

RELEASES.md

@@ -94,6 +94,9 @@ Input processors allow you to create custom logic for axis-like input manipulati
 - Actions can now be disabled at both the individual action and `ActionState` level
 - Disabling actions now resets their value, exposed via the `ActionState::reset` method
 - `ActionState::release_all` has been renamed to `ActionState::reset_all` and now resets the values of `Axislike` and `DualAxislike` actions
+- the state of actions now continues to be updated while they are disabled. However, when checked, their value is always released / zero.
+  - this ensures that holding down an action, disabling it and then re-enabling it does not trigger just-pressed
+  - the values of disabled actions can be accessed by checking their `ActionData` directly
 
 ### Usability (0.15)
 

src/action_state/mod.rs

@@ -20,6 +20,8 @@ pub use action_data::*;
 ///
 /// Can be used as either a resource or as a [`Component`] on entities that you wish to control directly from player input.
 ///
+/// # Disabling actions
+///
 /// Actions can be disabled in four different ways, with increasing granularity:
 ///
 /// 1. By disabling updates to all actions using a run condition on [`InputManagerSystem::Update`](crate::plugin::InputManagerSystem::Update).
@@ -30,7 +32,13 @@ pub use action_data::*;
 /// More general mechanisms of disabling actions will cause specific mechanisms to be ignored.
 /// For example, if an entire action state is disabled, then enabling or disabling individual actions will have no effect.
 ///
+/// Actions that are disabled will report as released (but not just released), and their values will be zero.
+/// Under the hood, their values are still updated to avoid surprising behavior when re-enabled,
+/// but they are not reported to the user using standard methods like [`ActionState::pressed`].
+/// To check the underlying values, access their [`ActionData`] directly.
+///
 /// # Example
+///
 /// ```rust
 /// use bevy::reflect::Reflect;
 /// use leafwing_input_manager::prelude::*;
@@ -121,12 +129,9 @@ impl<A: Actionlike> ActionState<A> {
     /// The `action_data` is typically constructed from [`InputMap::process_actions`](crate::input_map::InputMap::process_actions),
     /// which reads from the assorted [`ButtonInput`](bevy::input::ButtonInput) resources.
     ///
-    /// If this [`ActionState`] is disabled, it will not be updated.
+    /// Actions that are disabled will still be updated: instead, their values will be read as released / zero.
+    /// You can see their underlying values by checking their [`ActionData`] directly.
     pub fn update(&mut self, updated_actions: UpdatedActions<A>) {
-        if self.disabled {
-            return;
-        }
-
         for (action, updated_value) in updated_actions.iter() {
             match updated_value {
                 UpdatedValue::Button(pressed) => {
@@ -471,6 +476,10 @@ impl<A: Actionlike> ActionState<A> {
     pub fn value(&self, action: &A) -> f32 {
         debug_assert_eq!(action.input_control_kind(), InputControlKind::Axis);
 
+        if self.action_disabled(action) {
+            return 0.0;
+        }
+
         match self.axis_data(action) {
             Some(axis_data) => axis_data.value,
             None => 0.0,
@@ -514,6 +523,10 @@ impl<A: Actionlike> ActionState<A> {
     pub fn axis_pair(&self, action: &A) -> Vec2 {
         debug_assert_eq!(action.input_control_kind(), InputControlKind::DualAxis);
 
+        if self.action_disabled(action) {
+            return Vec2::ZERO;
+        }
+
         let action_data = self.dual_axis_data(action);
         action_data.map_or(Vec2::ZERO, |action_data| action_data.pair)
     }