feat: Add settings GUI for overlay configuration and custom key mapping, and refactor build process to generate both debug and release versions.

Author: Ian-bug

.gitignore

@@ -6,4 +6,5 @@ config.ini
 build/
 dist/
 *.spec
-*.zip
+*.zip
+RainingKeysPython-debug

README.md

@@ -75,7 +75,10 @@ RainingKeysPython/
 ### Debug vs Release Build
 You can toggle the console window visibility via `config.ini`:** window (controls settings).
 3.  Use the Config window to move the overlay or change speed/direction live.
-4.  Press the configured keys (Default: `a`, `s`, `l`, `;`) to see the visualization.
+4.  **Configure Lanes**:
+    -   Click "Record Lane Keys" in the config window.
+    -   Press the keys you want to bind (e.g., `Z`, `X`, `.`, `/`).
+    -   Click "Stop Recording" to save. The overlay uses these keys immediately.
 5.  **To Exit**: Close the Config window or press `Ctrl+C` in the terminal.
 
 ## Configuration
@@ -91,6 +94,7 @@ You can edit this file manually or use the **GUI Settings Window**.
 | `Visual` | `fall_direction` | `down` or `up`. |
 | `Position` | `x` | Overlay X position (pixels). |
 | `Position` | `y` | Overlay Y position (pixels). |
+| `lanes` | `keys` | Comma-separated list of keys (e.g., `'z','x','.'`). |
 
 *Note: Key mappings and colors are currently defined in `core/config.py`.*
 
@@ -100,7 +104,7 @@ You can edit this file manually or use the **GUI Settings Window**.
 - [x] Save/Load config from ini
 - [ ] Multi-monitor support
 - [ ] Custom color
-- [ ] Custom key mapping 
+- [x] Custom key mapping 
 
 ## Disclaimer
 

build.py

@@ -10,33 +10,7 @@
 EXECUTABLE_NAME = 'RainingKeysPython'
 MAIN_SCRIPT = 'main.py'
 
-def read_config():
-    """
-    Reads debug_mode from config.ini or config.cfg.
-    Returns boolean: True (Debug), False (Release).
-    Defaults to False if not specified.
-    """
-    config = configparser.ConfigParser()
-    
-    # Try to read config files
-    found_files = config.read(CONFIG_FILES)
-    if not found_files:
-        print(f"Warning: No config file found ({'/'.join(CONFIG_FILES)}). Defaulting to Release mode.")
-        return False
-
-    # Check for debug_mode in [General] section (or others if widely used)
-    # We prioritize [General] > [Debug] > global search if needed, but [General] is standard.
-    if config.has_section('General'):
-        if config.has_option('General', 'debug_mode'):
-            return config.getboolean('General', 'debug_mode')
-            
-    # Fallback: check if it's in a [Debug] section
-    if config.has_section('Debug'):
-        if config.has_option('Debug', 'debug_mode'):
-            return config.getboolean('Debug', 'debug_mode')
-
-    print("Info: 'debug_mode' not found in config. Defaulting to Release mode.")
-    return False
+
 
 def clean_directories():
     """Removes build and dist directories."""
@@ -53,6 +27,7 @@ def build(debug_mode):
     cmd = [
         'pyinstaller',
         '--onedir',
+        '--noconfirm',
         '--clean',
         '--name', EXECUTABLE_NAME,
         MAIN_SCRIPT
@@ -111,32 +86,74 @@ def create_zip(debug_mode):
     shutil.make_archive(zip_name, 'zip', root_dir=OUTPUT_DIR, base_dir=EXECUTABLE_NAME)
     print(f"Zip created: {zip_name}.zip")
 
-def main():
-    # 1. Clean previous builds
-    clean_directories()
-
-    # 2. Determine mode
-    debug_mode = read_config()
-
-    # 3. Build
+def update_config_debug_mode(debug_mode):
+    """Updates config.ini to match the current build mode."""
+    # We read the config to preserve other settings, but force debug_mode
+    config = configparser.ConfigParser()
+    config.read(CONFIG_FILES)
+    
+    # Ensure sections exist
+    if not config.has_section('General'):
+        if config.has_section('Debug'):
+            # Legacy support if user uses [Debug]
+            config.set('Debug', 'debug_mode', str(debug_mode))
+        else:
+            config.add_section('General')
+            config.set('General', 'debug_mode', str(debug_mode))
+    else:
+         config.set('General', 'debug_mode', str(debug_mode))
+    
+    # Write back
+    # We pick the first available config file to write to, usually config.ini
+    target_cfg = CONFIG_FILES[0]
+    with open(target_cfg, 'w') as f:
+        config.write(f)
+
+def run_build_cycle(debug_mode):
+    print(f"\n>>> Starting {'DEBUG' if debug_mode else 'RELEASE'} Build Cycle <<<")
+    
+    # Update config file so the built executable reads the correct mode at runtime
+    # AND so that the copy_config_to_dist puts the correct config in the dist folder
+    update_config_debug_mode(debug_mode)
+    
+    # Build
     try:
         build(debug_mode)
     except subprocess.CalledProcessError as e:
         print(f"Error during build: {e}")
         sys.exit(1)
+        
+    # Copy Config
+    copy_config_to_dist()
+    
+    # Zip
+    create_zip(debug_mode)
+
+def main():
+    # 1. Clean previous builds once at the start
+    clean_directories()
+
+    # 2. Check dependencies
+    try:
+        subprocess.call(['pyinstaller', '--version'], stdout=subprocess.DEVNULL)
     except FileNotFoundError:
          print("Error: 'pyinstaller' not found. Please install it via 'pip install pyinstaller'.")
          sys.exit(1)
 
-    # 4. Copy config
-    copy_config_to_dist()
-
-    # 5. Zip
-    create_zip(debug_mode)
-
-    print("\nBuild and packaging complete!")
-    print(f"Output folder: {os.path.join(OUTPUT_DIR, EXECUTABLE_NAME)}")
-    print(f"Zip file: {EXECUTABLE_NAME + ('-debug' if debug_mode else '')}.zip")
+    # 3. Release Build (Normal)
+    run_build_cycle(debug_mode=False)
+    
+    # 4. Debug Build
+    # We clean build/ between runs to ensure clean state, but NOT dist/ (so we keep the zips)
+    if os.path.exists(BUILD_DIR):
+        shutil.rmtree(BUILD_DIR)
+        
+    run_build_cycle(debug_mode=True)
+
+    print("\nAll builds complete!")
+    print(f"Artifacts located in project root:")
+    print(f" - {EXECUTABLE_NAME}.zip")
+    print(f" - {EXECUTABLE_NAME}-debug.zip")
 
 if __name__ == "__main__":
     main()

core/gui.py

@@ -1,14 +1,21 @@
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QLabel, QSpinBox, QComboBox, QGroupBox
-from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QLabel, QSpinBox, QComboBox, QGroupBox, QPushButton
+from PySide6.QtCore import Qt, Slot
+from PySide6.QtGui import QColor, QPalette
 from .settings_manager import SettingsManager
+from .config import Config
 
 class SettingsWindow(QWidget):
     def __init__(self, settings_manager: SettingsManager):
         super().__init__()
         self.settings = settings_manager
-        self.init_ui()
         self.setWindowTitle("RainingKeys Config")
-        self.resize(300, 250)
+        self.resize(300, 350)
+
+        # Recording State
+        self.is_recording = False
+        self.recorded_keys = []
+        
+        self.init_ui()
 
     def init_ui(self):
         layout = QVBoxLayout()
@@ -62,6 +69,25 @@ def init_ui(self):
         vis_group.setLayout(vis_layout)
         layout.addWidget(vis_group)
 
+        # Lane Configuration Group
+        lane_group = QGroupBox("Lane Configuration")
+        lane_layout = QVBoxLayout()
+        
+        self.lbl_lane_status = QLabel("Current Keys: " + str(len(Config.LANE_MAP)))
+        self.lbl_lane_status.setWordWrap(True)
+        lane_layout.addWidget(self.lbl_lane_status)
+        
+        self.btn_record = QPushButton("Record Lane Keys")
+        self.btn_record.clicked.connect(self.toggle_recording)
+        lane_layout.addWidget(self.btn_record)
+        
+        self.lbl_instruction = QLabel("Click 'Record', then press keys in order.\nClick 'Stop' when done.")
+        self.lbl_instruction.setStyleSheet("color: gray; font-size: 10px;")
+        lane_layout.addWidget(self.lbl_instruction)
+
+        lane_group.setLayout(lane_layout)
+        layout.addWidget(lane_group)
+        
         layout.addStretch()
         self.setLayout(layout)
 
@@ -74,3 +100,35 @@ def on_visual_changed(self):
         self.settings.set('Visual', 'fall_direction', self.combo_dir.currentText())
         self.settings.set('Visual', 'scroll_speed', self.spin_speed.value())
         self.settings.save()
+
+    def toggle_recording(self):
+        if not self.is_recording:
+            # Start Recording
+            self.is_recording = True
+            self.recorded_keys = []
+            self.btn_record.setText("Stop Recording")
+            self.lbl_lane_status.setText("Recording... Press keys!")
+            self.lbl_lane_status.setStyleSheet("color: red; font-weight: bold;")
+        else:
+            # Stop Recording
+            self.is_recording = False
+            self.btn_record.setText("Record Lane Keys")
+            self.lbl_lane_status.setStyleSheet("")
+            
+            if self.recorded_keys:
+                # Save
+                self.settings.save_lanes(self.recorded_keys)
+                self.lbl_lane_status.setText(f"Saved {len(self.recorded_keys)} lane keys.")
+                
+                # Update overlay if needed? save_lanes emits settings_changed which overlay listens to.
+            else:
+                 self.lbl_lane_status.setText("No keys recorded. Canceled.")
+
+    @Slot(str)
+    def handle_raw_key(self, key_str):
+        """Slot to receive raw keys from InputMonitor."""
+        if self.is_recording:
+            # Avoid duplicates if desired
+            if key_str not in self.recorded_keys:
+                self.recorded_keys.append(key_str)
+                self.lbl_lane_status.setText(f"Recorded: {', '.join(self.recorded_keys)}")

core/input_mon.py

@@ -10,6 +10,7 @@ class InputWorker(QObject):
     """
     key_pressed = Signal(int, float)  # lane_index, timestamp
     key_released = Signal(int, float) # lane_index, timestamp
+    raw_key_pressed = Signal(str)     # raw_key_string
 
     def __init__(self):
         super().__init__()
@@ -47,6 +48,8 @@ def on_press(self, key):
         if k_str in self.active_keys:
             return
 
+        self.raw_key_pressed.emit(k_str)
+
         if k_str in Config.LANE_MAP:
             self.active_keys.add(k_str)
             timestamp = time.perf_counter()
@@ -73,12 +76,14 @@ class InputMonitor(QThread):
     """
     key_pressed = Signal(int, float)
     key_released = Signal(int, float)
+    raw_key_pressed = Signal(str)
 
     def __init__(self):
         super().__init__()
         self.worker = InputWorker()
         self.worker.key_pressed.connect(self.key_pressed.emit)
         self.worker.key_released.connect(self.key_released.emit)
+        self.worker.raw_key_pressed.connect(self.raw_key_pressed.emit)
 
     def run(self):
         self.worker.start_monitoring()

core/overlay.py

@@ -99,19 +99,11 @@ def init_ui(self):
         self.setAttribute(Qt.WA_TranslucentBackground)
         self.setAttribute(Qt.WA_TransparentForMouseEvents)
 
-        # Initial calculation for window size
-        # We need enough width for all lanes
-        max_lane = 0
-        if Config.LANE_MAP:
-             max_lane = max(Config.LANE_MAP.values())
-        
-        # Width: Start Offset + (Max Lane Index + 1) * Lane Width + Extra Padding
-        width = Config.LANE_START_X + ((max_lane + 1) * Config.LANE_WIDTH) + 50
-        height = QApplication.primaryScreen().size().height()
+        self.setAttribute(Qt.WA_TransparentForMouseEvents)
 
-        self.resize(width, height)
-        # Move to configured position
-        self.move(self.settings.overlay_x, self.settings.overlay_y)
+        self.update_layout()
+
+        # Win32 Click-through
 
         # Win32 Click-through
         if HAS_WIN32:
@@ -125,6 +117,21 @@ def init_ui(self):
     def on_settings_changed(self):
         # Move window live when settings change
         self.move(self.settings.overlay_x, self.settings.overlay_y)
+        self.update_layout() # Recalculate size if lanes changed
+
+    def update_layout(self):
+        """Recalculates window size based on current lanes."""
+        max_lane = 0
+        if Config.LANE_MAP:
+             max_lane = max(Config.LANE_MAP.values())
+        else:
+             max_lane = 0 # Fallback
+        
+        # Width: Start Offset + (Max Lane Index + 1) * Lane Width + Extra Padding
+        width = Config.LANE_START_X + ((max_lane + 1) * Config.LANE_WIDTH) + 50
+        height = QApplication.primaryScreen().size().height()
+        
+        self.resize(width, height)
 
     def handle_input(self, lane_index, timestamp):
         """Slot called when input monitor detects a key press."""

core/settings_manager.py

@@ -24,6 +24,9 @@ def _load(self):
         if not self.config.has_section('Position'):
             self.config.add_section('Position')
             changed = True
+        if not self.config.has_section('lanes'):
+            self.config.add_section('lanes')
+            changed = True
 
         # Defaults
         if not self.config.has_option('Visual', 'scroll_speed'):
@@ -39,6 +42,15 @@ def _load(self):
             self.config.set('Position', 'y', str(0))
             changed = True
 
+        if not self.config.has_option('lanes', 'keys'):
+            # Default keys
+            default_keys = "'a','s','l',';'"
+            self.config.set('lanes', 'keys', default_keys)
+            changed = True
+        
+        # Apply lanes to Config
+        self._apply_lanes()
+            
         if changed:
             self.save()
 
@@ -64,6 +76,27 @@ def save(self):
             self.config.write(f)
         self.settings_changed.emit()
 
+    def _apply_lanes(self):
+        """Reads keys from config and updates Config.LANE_MAP."""
+        if self.config.has_option('lanes', 'keys'):
+            keys_str = self.config.get('lanes', 'keys')
+            key_list = [k.strip() for k in keys_str.split(',') if k.strip()]
+            
+            # Rebuild map
+            Config.LANE_MAP.clear()
+            for idx, k in enumerate(key_list):
+                Config.LANE_MAP[k] = idx
+                
+    def save_lanes(self, key_list):
+        """Saves a list of key strings to config."""
+        keys_str = ",".join(key_list)
+        if not self.config.has_section('lanes'):
+            self.config.add_section('lanes')
+        self.config.set('lanes', 'keys', keys_str)
+        self.save() # Saves to file
+        self._apply_lanes() # Updates runtime config
+        self.settings_changed.emit() # Notify UI/Overlay
+
     # Properties for easy access
     @property
     def scroll_speed(self):