Don't merge non-active trackers

src/input_context/context_instance.rs

@@ -29,11 +29,11 @@ use crate::{
 ///    1.1. Apply input-level [`InputModifier`]s.
 ///    1.2. Evaluate input-level [`InputCondition`]s, combining their results based on their [`InputCondition::kind`].
 /// 2. Select all [`ActionValue`]s with the most significant [`ActionState`] and combine based on [`InputAction::ACCUMULATION`].
-///    The value will also be converted using [`ActionValue::convert`] into [`InputAction::DIM`].
+///    Combined value be converted into [`InputAction::DIM`] dimention using [`ActionValue::convert`].
 /// 3. Apply action level [`InputModifier`]s.
 /// 4. Evaluate action level [`InputCondition`]s, combining their results according to [`InputCondition::kind`].
 /// 5. Set the final [`ActionState`] based on the results.
-///    The value will also be converted using [`ActionValue::convert`] into [`InputAction::DIM`].
+///    Final value be converted into [`InputAction::DIM`] dimention using [`ActionValue::convert`].
 ///
 /// New instances won't react to currently held inputs until they are released.
 /// This prevents unintended behavior where switching contexts using the same key

src/input_context/input_action.rs

@@ -443,7 +443,8 @@ pub trait InputAction: Debug + Send + Sync + 'static {
     const ACCUMULATION: Accumulation = Accumulation::Cumulative;
 }
 
-/// Defines how [`ActionValue`] is calculated when multiple inputs are evaluated with the same [`ActionState`].
+/// Defines how [`ActionValue`] is calculated when multiple inputs are evaluated with the
+/// same most significant [`ActionState`] (excluding [`ActionState::None`]).
 #[derive(Default, Clone, Copy, Debug)]
 pub enum Accumulation {
     /// Cumulatively add the key values for each mapping.

src/input_context/trigger_tracker.rs

@@ -120,7 +120,15 @@ impl TriggerTracker {
 
     /// Merges input-level tracker into an action-level tracker.
     pub(super) fn merge(&mut self, other: Self, accumulation: Accumulation) {
-        match self.state().cmp(&other.state()) {
+        let other_state = other.state();
+        if other_state == ActionState::None {
+            // Don't merge non-active trackers to allow the action to fire even if all
+            // input-level conditions return `ActionState::None`. This ensures that an
+            // action-level condition or modifier can still trigger the action.
+            return;
+        }
+
+        match self.state().cmp(&other_state) {
             Ordering::Less => {
                 let dim = self.value.dim();
                 *self = other;

tests/state_and_value_merge.rs

@@ -78,7 +78,7 @@ fn input_level() {
     let recorded = app.world().resource::<RecordedActions>();
     let events = recorded.get::<InputLevel>(entity).unwrap();
     let event = events.last().unwrap();
-    assert_eq!(event.value, Vec2::Y.into());
+    assert_eq!(event.value, Vec2::ZERO.into());
     assert_eq!(
         event.state,
         ActionState::None,