commit fcfe3ce9f732088ccbd0f351a44484d02a093f6d · ptr.pet/osuclack

+65 -31
src/main.rs
···

       39
       39
        
           let mut previously_held_keys = HashSet::<Keycode>::new();

     

       40
       40
        
           let mut key_press_times = HashMap::<Keycode, std::time::Instant>::new();

     

       41
       41
        
           let mut last_sound_time = std::time::Instant::now();

     

       42
       42
       +
           let mut sounds_enabled = true; // Toggle for enabling/disabling sounds

     

       42
       43
        
       

     

       43
       44
        
           let initial_delay = Duration::from_millis(500); // Wait 500ms before starting to repeat

     

       44
       45
        
           let repeat_interval = Duration::from_millis(50); // Then repeat every 50ms

     
···

       46
       47
        
           loop {

     

       47
       48
        
               let currently_held_keys: HashSet<Keycode> = state.query_keymap().into_iter().collect();

     

       48
       49
        
       

     

       49
       49
       -
               // Track when keys were first pressed

     

       50
       50
       -
               for key in &currently_held_keys {

     

       51
       51
       -
                   if !previously_held_keys.contains(key) {

     

       52
       52
       -
                       // Key just pressed, record the time and play initial sound

     

       53
       53
       -
                       key_press_times.insert(*key, std::time::Instant::now());

     

       54
       54
       -
                       play_sound_for_key(*key);

     

       55
       55
       -
                   }

     

       56
       56
       -
               }

     

       50
       50
       +
               // Check for toggle hotkey (Ctrl + Alt + L/R Shift + C)

     

       51
       51
       +
               let hotkey_combo = [

     

       52
       52
       +
                   [Keycode::LControl, Keycode::RControl], // Either left or right control

     

       53
       53
       +
                   [Keycode::LAlt, Keycode::RAlt],         // Either left or right alt

     

       54
       54
       +
                   [Keycode::LShift, Keycode::RShift],     // Either left or right shift

     

       55
       55
       +
                   [Keycode::C, Keycode::C],               // C key (duplicated for array consistency)

     

       56
       56
       +
               ];

     

       57
       57
        
       

     

       58
       58
       -
               // Remove timing info for released keys

     

       59
       59
       -
               key_press_times.retain(|key, _| currently_held_keys.contains(key));

     

       58
       58
       +
               let check_hotkey = |current: &HashSet<Keycode>, previous: &HashSet<Keycode>| {

     

       59
       59
       +
                   hotkey_combo.iter().all(|key_group| {

     

       60
       60
       +
                       key_group

     

       61
       61
       +
                           .iter()

     

       62
       62
       +
                           .any(|key| current.contains(key) || previous.contains(key))

     

       63
       63
       +
                   })

     

       64
       64
       +
               };

     

       60
       65
        
       

     

       61
       61
       -
               // Play repeating sounds every 50ms, but only after initial delay

     

       62
       62
       -
               if last_sound_time.elapsed() >= repeat_interval {

     

       63
       63
       -
                   let now = std::time::Instant::now();

     

       66
       66
       +
               let hotkey_active = check_hotkey(&currently_held_keys, &previously_held_keys);

     

       67
       67
       +
               let hotkey_was_active = check_hotkey(&previously_held_keys, &HashSet::new());

     

       68
       68
       +
       

     

       69
       69
       +
               if hotkey_active && !hotkey_was_active {

     

       70
       70
       +
                   sounds_enabled = !sounds_enabled;

     

       71
       71
       +
               }

     

       72
       72
       +
       

     

       73
       73
       +
               // Only process sound logic if sounds are enabled

     

       74
       74
       +
               if sounds_enabled {

     

       75
       75
       +
                   // Track when keys were first pressed

     

       64
       76
        
                   for key in &currently_held_keys {

     

       65
       65
       -
                       if matches!(

     

       66
       66
       -
                           key,

     

       67
       67
       -
                           Keycode::LShift

     

       68
       68
       -
                               | Keycode::RShift

     

       69
       69
       -
                               | Keycode::LControl

     

       70
       70
       -
                               | Keycode::RControl

     

       71
       71
       -
                               | Keycode::RAlt

     

       72
       72
       -
                               | Keycode::LAlt

     

       73
       73
       -
                               | Keycode::RMeta

     

       74
       74
       -
                               | Keycode::LMeta

     

       75
       75
       -
                               | Keycode::CapsLock

     

       76
       76
       -
                       ) {

     

       77
       77
       -
                           continue;

     

       77
       77
       +
                       if !previously_held_keys.contains(key) {

     

       78
       78
       +
                           // Key just pressed, record the time and play initial sound

     

       79
       79
       +
                           key_press_times.insert(*key, std::time::Instant::now());

     

       80
       80
       +
                           play_sound_for_key(*key);

     

       78
       81
        
                       }

     

       79
       79
       -
                       if let Some(press_time) = key_press_times.get(key) {

     

       80
       80
       -
                           // Only repeat if key has been held longer than initial delay

     

       81
       81
       -
                           if now.duration_since(*press_time) >= initial_delay {

     

       82
       82
       -
                               play_sound_for_key(*key);

     

       82
       82
       +
                   }

     

       83
       83
       +
       

     

       84
       84
       +
                   // Remove timing info for released keys

     

       85
       85
       +
                   key_press_times.retain(|key, _| currently_held_keys.contains(key));

     

       86
       86
       +
       

     

       87
       87
       +
                   // Play repeating sounds every 50ms, but only after initial delay

     

       88
       88
       +
                   if last_sound_time.elapsed() >= repeat_interval {

     

       89
       89
       +
                       let now = std::time::Instant::now();

     

       90
       90
       +
                       for key in &currently_held_keys {

     

       91
       91
       +
                           if is_modifier_key(key) {

     

       92
       92
       +
                               continue;

     

       93
       93
       +
                           }

     

       94
       94
       +
                           if let Some(press_time) = key_press_times.get(key) {

     

       95
       95
       +
                               // Only repeat if key has been held longer than initial delay

     

       96
       96
       +
                               if now.duration_since(*press_time) >= initial_delay {

     

       97
       97
       +
                                   play_sound_for_key(*key);

     

       98
       98
       +
                               }

     

       83
       99
        
                           }

     

       84
       100
        
                       }

     

       101
       101
       +
                       last_sound_time = now;

     

       85
       102
        
                   }

     

       86
       86
       -
                   last_sound_time = now;

     

       103
       103
       +
               } else {

     

       104
       104
       +
                   // Clear key press times when sounds are disabled to avoid stale data

     

       105
       105
       +
                   key_press_times.clear();

     

       87
       106
        
               }

     

       88
       107
        
       

     

       89
       108
        
               previously_held_keys = currently_held_keys;

     
···

       92
       111
        
               std::thread::sleep(Duration::from_millis(5));

     

       93
       112
        
           }

     

       94
       113
        
       }

     

       114
       114
       +
       

     

       115
       115
       +
       fn is_modifier_key(key: &Keycode) -> bool {

     

       116
       116
       +
           matches!(

     

       117
       117
       +
               key,

     

       118
       118
       +
               Keycode::LShift

     

       119
       119
       +
                   | Keycode::RShift

     

       120
       120
       +
                   | Keycode::LControl

     

       121
       121
       +
                   | Keycode::RControl

     

       122
       122
       +
                   | Keycode::RAlt

     

       123
       123
       +
                   | Keycode::LAlt

     

       124
       124
       +
                   | Keycode::RMeta

     

       125
       125
       +
                   | Keycode::LMeta

     

       126
       126
       +
                   | Keycode::CapsLock

     

       127
       127
       +
           )

     

       128
       128
       +
       }