Easy mode ain't so easy anymore!

Enhanced brutal mode exit traps and easy mode shortcuts with improved user experience and error handling.

brutal.c: +72/-15
brutal.h: +21/-0
edit.c: +40/-0
normal.c: +44/-15

Author: mcollard0

src/nvim/brutal.c

@@ -22,6 +22,7 @@ BrutalMode brutal_mode = BRUTAL_NONE;
 uint8_t brutal_keymap[256];
 uint64_t brutal_esc_hold_start = 0;
 int brutal_ctrl_quit_count = 0;
+uint64_t brutal_ctrl_quit_times[5] = {0};
 uint64_t brutal_esc_press_times[5] = {0};
 int brutal_esc_press_count = 0;
 char brutal_easter_egg_buffer[32] = {0};
@@ -127,7 +128,12 @@ void brutal_init( void )
 
     // Set selectmode to "key" so Shift+Arrow enters select mode
     do_cmdline_cmd( "set selectmode=key" );
+    // Set keymodel to start selection with shift-keys
+    do_cmdline_cmd( "set keymodel=startsel,stopsel" );
   }
+
+  // Add :Q command alias for :quit
+  do_cmdline_cmd("command! Q quit");
 }
 
 /// Display brutal mode startup banner
@@ -291,7 +297,58 @@ bool brutal_should_block_quit( bool force )
   return ( brutal_mode == BRUTAL_HARDER || brutal_mode == BRUTAL_HARDEST );
 }
 
-/// Handle easy mode special quit sequences
+/// Reset the quit counter
+void brutal_reset_ctrl_quit_count( void )
+{
+  brutal_ctrl_quit_count = 0;
+  for ( int i = 0; i < 5; i++ ) {
+    brutal_ctrl_quit_times[i] = 0;
+  }
+}
+
+/// Increment the quit counter and check time window
+void brutal_increment_ctrl_quit_count( void )
+{
+  uint64_t now = os_hrtime();
+
+  // Shift timestamps (keep last 5)
+  brutal_ctrl_quit_times[4] = brutal_ctrl_quit_times[3];
+  brutal_ctrl_quit_times[3] = brutal_ctrl_quit_times[2];
+  brutal_ctrl_quit_times[2] = brutal_ctrl_quit_times[1];
+  brutal_ctrl_quit_times[1] = brutal_ctrl_quit_times[0];
+  brutal_ctrl_quit_times[0] = now;
+
+  if ( brutal_ctrl_quit_count < 3 ) {
+    brutal_ctrl_quit_count++;
+  }
+}
+
+/// Check if quit counter reached threshold (3) within time window
+bool brutal_check_ctrl_quit( void )
+{
+  if ( brutal_ctrl_quit_count >= 3 ) {
+    uint64_t now = os_hrtime();
+    uint64_t eight_seconds_ns = 8000000000ULL;  // 8 seconds
+
+    // Check if 3rd press back (index 2) is within 8 seconds
+    if ( brutal_ctrl_quit_times[2] != 0 &&
+         ( now - brutal_ctrl_quit_times[2] ) <= eight_seconds_ns ) {
+      return true;
+    } else {
+        // Reset if timeout expired, but keep the current press as the first one
+        brutal_ctrl_quit_count = 1;
+        // The current timestamp is already at [0], clear others
+        brutal_ctrl_quit_times[1] = 0;
+        brutal_ctrl_quit_times[2] = 0;
+        brutal_ctrl_quit_times[3] = 0;
+        brutal_ctrl_quit_times[4] = 0;
+        return false;
+    }
+  }
+  return false;
+}
+
+/// Handle easy mode special quit sequences (unused now, replaced by direct checks)
 /// @param c The character pressed
 /// @return true if quit was triggered
 bool brutal_easy_mode_quit_check( int c )
@@ -302,32 +359,32 @@ bool brutal_easy_mode_quit_check( int c )
 
   // Check for Ctrl+X, Ctrl+C, or Ctrl+Q
   if ( c == Ctrl_X || c == Ctrl_C || c == Ctrl_Q ) {
-    brutal_ctrl_quit_count++;
-    if ( brutal_ctrl_quit_count >= 3 ) {
+    brutal_increment_ctrl_quit_count();
+    if ( brutal_check_ctrl_quit() ) {
       return true;  // Trigger quit
     }
   } else {
-    brutal_ctrl_quit_count = 0;  // Reset counter
+    brutal_reset_ctrl_quit_count();  // Reset counter
   }
 
   return false;
 }
 
-/// Check if ESC has been pressed repeatedly (5 times within 10 seconds)
+/// Check if ESC has been pressed repeatedly (3 times within 10 seconds)
 /// @return true if threshold met
 bool brutal_easy_mode_esc_repeated( void )
 {
   if ( brutal_mode != BRUTAL_EASY ) {
     return false;
   }
 
-  // Check if we have 5 ESC presses
-  if ( brutal_esc_press_count >= 5 ) {
+  // Check if we have 3 ESC presses
+  if ( brutal_esc_press_count >= 3 ) {
     uint64_t now = os_hrtime();
     uint64_t ten_seconds_ns = 10000000000ULL;  // 10 seconds
 
-    // Check if oldest press (4th back) is within 10 seconds
-    if ( now - brutal_esc_press_times[4] <= ten_seconds_ns ) {
+    // Check if oldest press (2nd back) is within 10 seconds
+    if ( now - brutal_esc_press_times[2] <= ten_seconds_ns ) {
       return true;
     }
   }
@@ -451,25 +508,25 @@ void brutal_handle_esc_press( void )
   brutal_esc_press_times[0] = now;
 
   // Increment counter
-  if ( brutal_esc_press_count < 5 ) {
+  if ( brutal_esc_press_count < 3 ) {
     brutal_esc_press_count++;
   }
 }
 
-/// Check if 5 ESC presses detected in EASY mode within 10 seconds
+/// Check if 3 ESC presses detected in EASY mode within 10 seconds
 bool brutal_check_repeated_esc( void )
 {
   if ( brutal_mode != BRUTAL_EASY ) {
     return false;
   }
 
-  if ( brutal_esc_press_count >= 5 ) {
+  if ( brutal_esc_press_count >= 3 ) {
     uint64_t now = os_hrtime();
     uint64_t ten_seconds_ns = 10000000000ULL;
 
-    // Check if 5th press back is within 10 seconds
-    if ( brutal_esc_press_times[4] != 0 && 
-         ( now - brutal_esc_press_times[4] ) <= ten_seconds_ns ) {
+    // Check if 3rd press back (index 2) is within 10 seconds
+    if ( brutal_esc_press_times[2] != 0 &&
+         ( now - brutal_esc_press_times[2] ) <= ten_seconds_ns ) {
       // Reset counter
       brutal_esc_press_count = 0;
       for ( int i = 0; i < 5; i++ ) {

src/nvim/brutal.h

@@ -21,13 +21,34 @@ extern uint8_t brutal_keymap[256];
 /// Easy mode state tracking
 extern uint64_t brutal_esc_hold_start;  ///< Unused (kept for compatibility)
 extern int brutal_ctrl_quit_count;      ///< Count of consecutive ctrl+x/c/q presses
+extern uint64_t brutal_ctrl_quit_times[5];  ///< Timestamps of last 5 Ctrl-C/X/Q presses
 extern uint64_t brutal_esc_press_times[5];  ///< Timestamps of last 5 ESC presses
 extern int brutal_esc_press_count;      ///< Count of ESC presses
 
 /// Easter egg buffer for "fuck you let me out"
 extern char brutal_easter_egg_buffer[32];
 extern int brutal_easter_egg_pos;
 
+/// Function prototypes
+void brutal_init(void);
+void brutal_show_banner(void);
+bool brutal_should_block_key(int c);
+int brutal_apply_easy_mode_mappings(int c);
+int brutal_remap_key(int c);
+bool brutal_windows_keys_active(void);
+bool brutal_should_block_quit(bool force);
+bool brutal_easy_mode_quit_check(int c);
+bool brutal_easy_mode_esc_repeated(void);
+bool brutal_check_easter_egg(void);
+void brutal_record_char(int c);
+void brutal_handle_esc_press(void);
+bool brutal_check_repeated_esc(void);
+
+// New functions for managing quit counter explicitly
+void brutal_reset_ctrl_quit_count(void);
+void brutal_increment_ctrl_quit_count(void);
+bool brutal_check_ctrl_quit(void);
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "brutal.h.generated.h"
 #endif

src/nvim/edit.c

@@ -13,6 +13,7 @@
 #include "nvim/ascii_defs.h"
 #include "nvim/autocmd.h"
 #include "nvim/autocmd_defs.h"
+#include "nvim/brutal.h"
 #include "nvim/buffer.h"
 #include "nvim/buffer_defs.h"
 #include "nvim/change.h"
@@ -678,6 +679,11 @@ static int insert_execute(VimState *state, int key)
   }
 
   if (s->c == Ctrl_V || s->c == Ctrl_Q) {
+    if (brutal_mode == BRUTAL_EASY && s->c == Ctrl_V) {
+      // Paste from clipboard (+)
+      do_put('+', NULL, BACKWARD, 1, PUT_CURSEND);
+      return 1; // Stay in Insert mode
+    }
     ins_ctrl_v();
     s->c = Ctrl_V;       // pretend CTRL-V is last typed character
     return 1;  // continue
@@ -740,6 +746,26 @@ static int insert_handle_key(InsertState *s)
     FALLTHROUGH;
 
   case Ctrl_C:        // End input mode
+    if (s->c == Ctrl_C && brutal_mode == BRUTAL_EASY) {
+      if (VIsual_active) {
+        // Visual/Select active: Copy to clipboard and reset counter
+        do_cmdline_cmd("normal! \"+y");
+        brutal_reset_ctrl_quit_count();
+        // Return to Insert mode
+        return 1; // Continue in Insert mode
+      } else {
+        // No selection: Increment counter
+        brutal_increment_ctrl_quit_count();
+        if (brutal_check_ctrl_quit()) {
+           // Exit app
+           do_cmdline_cmd("qa!");
+           return 0;
+        }
+        // Don't exit insert mode
+        return 1;
+      }
+    }
+
     if (s->c == Ctrl_C && cmdwin_type != 0) {
       // Close the cmdline window.
       cmdwin_result = K_IGNORE;
@@ -761,6 +787,10 @@ static int insert_handle_key(InsertState *s)
     return 0;  // exit insert mode
 
   case Ctrl_Z:
+    if (brutal_mode == BRUTAL_EASY) {
+      u_undo(1);
+      return 1; // Stay in Insert mode
+    }
     goto normalchar;                // insert CTRL-Z as normal char
 
   case Ctrl_O:        // execute one command
@@ -893,6 +923,10 @@ static int insert_handle_key(InsertState *s)
 
   case Ctrl_U:        // delete all inserted text in current line
     // CTRL-X CTRL-U completes with 'completefunc'.
+    if (brutal_mode == BRUTAL_EASY) {
+      u_undo(1);
+      return 1; // Stay in Insert mode
+    }
     if (ctrl_x_mode_function()) {
       insert_do_complete(s);
     } else {
@@ -1137,6 +1171,12 @@ static int insert_handle_key(InsertState *s)
     goto normalchar;
 
   case Ctrl_X:        // Enter CTRL-X mode
+    if (brutal_mode == BRUTAL_EASY && VIsual_active) {
+        // Cut to clipboard (+)
+        do_cmdline_cmd("normal! \"+d");
+        brutal_reset_ctrl_quit_count();
+        return 1; // Stay in Insert mode
+    }
     ins_ctrl_x();
     break;
 

src/nvim/normal.c

@@ -1251,6 +1251,12 @@ static int normal_execute(VimState *state, int key)
   // Execute the command!
   // Call the command function found in the commands table.
   s->ca.arg = nv_cmds[s->idx].cmd_arg;
+
+  // Reset ESC quit counter if a non-ESC command is executed in Normal mode
+  if (brutal_mode == BRUTAL_EASY && s->ca.cmdchar != ESC && s->ca.cmdchar != K_IGNORE && s->ca.cmdchar != K_MOUSEMOVE) {
+      brutal_esc_press_count = 0;
+  }
+
   (nv_cmds[s->idx].cmd_func)(&s->ca);
 
 finish:
@@ -6151,23 +6157,46 @@ static void nv_esc(cmdarg_T *cap)
 
   // Brutal mode: Removed ESC detection (was unreliable)
 
+  // Handle ESC in Easy Mode (3x check)
+  if (brutal_mode == BRUTAL_EASY && !cap->arg) { // cap->arg is false for ESC
+      brutal_handle_esc_press();
+      if (brutal_check_repeated_esc()) {
+          do_cmdline_cmd("qa!");
+          return;
+      }
+  }
+
   if (cap->arg) {               // true for CTRL-C
     // EASY mode: Ctrl+C in visual mode copies to clipboard
-    if (VIsual_active && brutal_mode == BRUTAL_EASY) {
-      // Set up yank operator - use unnamed register (0 means use default)
-      // This ensures yank works even without clipboard provider
-      cap->oap->regname = 0;  // Use unnamed/default register
-      cap->oap->op_type = OP_YANK;
-      cap->cmdchar = 'y';  // Simulate 'y' command for do_pending_operator
-      
-      // Call do_pending_operator to execute the yank on the visual selection
-      do_pending_operator(cap, curwin->w_curswant, false);
-      
-      // Ensure clean state after operation
-      clearop(cap->oap);
-      // Clear got_int which may have been set by Ctrl+C signal
-      got_int = false;
-      return;
+    if (brutal_mode == BRUTAL_EASY) {
+        if (VIsual_active) {
+          // Set up yank operator - use unnamed register (0 means use default)
+          // This ensures yank works even without clipboard provider
+          cap->oap->regname = '+';  // Use + register for clipboard
+          cap->oap->op_type = OP_YANK;
+          cap->cmdchar = 'y';  // Simulate 'y' command for do_pending_operator
+
+          // Call do_pending_operator to execute the yank on the visual selection
+          do_pending_operator(cap, curwin->w_curswant, false);
+
+          // Ensure clean state after operation
+          clearop(cap->oap);
+          // Clear got_int which may have been set by Ctrl+C signal
+          got_int = false;
+          brutal_reset_ctrl_quit_count();
+          return;
+        } else {
+            // Normal mode, no selection: Increment counter
+            brutal_increment_ctrl_quit_count();
+            if (brutal_check_ctrl_quit()) {
+                do_cmdline_cmd("qa!");
+                return;
+            }
+            // Block standard Ctrl-C message
+            clearop(cap->oap);
+            got_int = false;
+            return;
+        }
     }
 
     if (restart_edit == 0 && cmdwin_type == 0 && !VIsual_active && no_reason) {