Add potion count check

- Read potion count from memory. Use potion only when count > 0.
- Overlay: show "Potions:" value.
- Console log: include remaining potions on each use.
- Standalone script potion_count.py for testing.

Author: leobrqz

build_release.sh

@@ -2,7 +2,7 @@
 pyinstaller \
   --clean \
   --onefile \
-  --name="AutoPot-DR-v1.0.1" \
+  --name="AutoPot-DR-v1.2.0" \
   --icon=../imgs/icon.ico \
   --add-data "../imgs;imgs" \
   --distpath release \

imgs/OverlayOFF.png

@@ -3,7 +3,7 @@
 [![Dwarven Realms](https://img.shields.io/badge/Dwarven%20Realms%20Version-5.3.2.0-purple)]()
 [![Windows](https://img.shields.io/badge/Platform-Windows-blue)]()
 
-A game tool for Dwarven Realms that automatically uses potions when HP drops below a configurable threshold. Attaches to the game process via pymem and reads player health data from memory using iterative pointer dereferencing with pointer chain resolution. Memory reading runs in a separate background thread with thread-safe operation. Features a PyQt5 overlay window with transparency and always-on-top behavior, and is also thread-safe for responsiveness. 
+A game tool for Dwarven Realms that automatically uses potions when HP drops below a configurable threshold and the player has at least one potion. Attaches to the game process via pymem and reads player health and potion count from memory using iterative pointer dereferencing. Memory reading runs in a separate background thread with thread-safe operation. Features a PyQt5 overlay window with transparency and always-on-top behavior and is also thread-safe for responsiveness. 
 
 **⚠️ Warning**: This tool is intended for **offline use only**. While it may work online, use it at your own risk and discretion.
 
@@ -19,12 +19,13 @@ A game tool for Dwarven Realms that automatically uses potions when HP drops bel
 
 <p align="center">
   <img src="imgs/OverlayOFF.png" alt="Overlay OFF" width="45%"/>
-  <img src="imgs/OverlayON.png" alt="Overlay ON" width="43.5%"/>
+  <img src="imgs/OverlayON.png" alt="Overlay ON" width="45%"/>
 </p>
 
-* **Auto Potion**: Automatically triggers a potion when HP falls below a set percentage.
-* **Potion log**: The overlay displays a log of recent potion uses, showing HP values and timestamps for each use.
-* **Overlay UI**: Movable, lockable PyQt5 overlay showing status, HP, and logs.
+* **Auto Potion**: Automatically triggers a potion when HP falls below a set percentage and the player has at least one potion (prevents spamming when out of potions).
+* **Potion count display**: The overlay shows the current potion count.
+* **Potion log**: The overlay displays a log of recent potion uses, showing HP values and timestamps for each use. The console log for each use also shows remaining potion count.
+* **Overlay UI**: Movable, lockable PyQt5 overlay showing status, potions, HP, and logs.
 * **Customizable Hotkeys**: Easily change hotkeys for toggling ON/OFF, locking, and closing the overlay.
 * **Safe & Configurable**: All settings in a user-friendly config file.
 

imgs/OverlayON.png

@@ -17,6 +17,8 @@ class Config:
     DEFAULT_MAX_HEALTH_OFFSETS = "0x30,0x940,0x5D0,0x2F0,0x370"
     DEFAULT_CURRENT_HEALTH_BASE_OFFSET = "0x064D8FD0"
     DEFAULT_CURRENT_HEALTH_OFFSETS = "0x30,0x8C8,0xB0,0x2F0,0x368"
+    DEFAULT_POTION_BASE_OFFSET = "0x064D8FD0"
+    DEFAULT_POTION_OFFSETS = "0x30,0x8A8,0xAC"
     DEFAULT_HOTKEY_LOCK = "home"
     DEFAULT_HOTKEY_TOGGLE = "insert"
     DEFAULT_HOTKEY_CLOSE = "end"
@@ -55,7 +57,9 @@ def _create_default_config(self):
             'max_health_base_offset': self.DEFAULT_MAX_HEALTH_BASE_OFFSET,
             'max_health_offsets': self.DEFAULT_MAX_HEALTH_OFFSETS,
             'current_health_base_offset': self.DEFAULT_CURRENT_HEALTH_BASE_OFFSET,
-            'current_health_offsets': self.DEFAULT_CURRENT_HEALTH_OFFSETS
+            'current_health_offsets': self.DEFAULT_CURRENT_HEALTH_OFFSETS,
+            'potion_base_offset': self.DEFAULT_POTION_BASE_OFFSET,
+            'potion_offsets': self.DEFAULT_POTION_OFFSETS
         }
 
         try:
@@ -108,6 +112,16 @@ def get_current_health_offsets(self):
         return self.config.get('POINTERCHAINS', 'current_health_offsets',
                               fallback=self.DEFAULT_CURRENT_HEALTH_OFFSETS)
 
+    def get_potion_base_offset(self):
+        """Get potion base offset (hex string)."""
+        return self.config.get('POINTERCHAINS', 'potion_base_offset',
+                              fallback=self.DEFAULT_POTION_BASE_OFFSET)
+    
+    def get_potion_offsets(self):
+        """Get potion offsets as comma-separated hex string."""
+        return self.config.get('POINTERCHAINS', 'potion_offsets',
+                              fallback=self.DEFAULT_POTION_OFFSETS)
+    
     def get_hotkey_lock(self):
         """Get hotkey for lock/unlock overlay."""
         return self.config.get('KEYBINDS', 'hotkey_lock',

readme.md

@@ -317,6 +317,9 @@ def set_enabled_wrapper(enabled):
     # Connect current health signal to overlay
     memory_reader.current_health_updated.connect(overlay.set_current_health)
 
+    # Connect potion count signal to overlay
+    memory_reader.potion_count_updated.connect(overlay.set_potion_count)
+    
     # Register hotkeys (will print hotkeys inside register_hotkeys())
     hotkey_manager = HotkeyManager(overlay, app, config)
     hotkey_manager.register_hotkeys()

src/config.py

@@ -223,6 +223,8 @@ class MemoryReader(QObject):
     process_attached = pyqtSignal()
     # Signal emitted when process death is detected
     process_died = pyqtSignal()
+    # Signal emitted when potion count is read (-1 for read failure)
+    potion_count_updated = pyqtSignal(int)
 
     def __init__(self, config, process_name, potion_key="r"):
         """
@@ -252,6 +254,8 @@ def __init__(self, config, process_name, potion_key="r"):
         self._process_id = None
         self._last_max_health_chain = None
         self._last_current_health_chain = None
+        self._potion_count_initialized = False
+        self._last_potion_chain = None
         self._attachment_notified = False  # Track if we've notified about current attachment
         self._last_chain_resolution_attempt = 0.0
         self._chain_resolution_cooldown = 1.0  # 1 second cooldown for chain resolution
@@ -273,9 +277,11 @@ def set_process_running(self, running: bool):
             self._module_base = None
             self._max_health_initialized = False
             self._current_health_initialized = False
+            self._potion_count_initialized = False
             self._process_id = None
             self._last_max_health_chain = None
             self._last_current_health_chain = None
+            self._last_potion_chain = None
             self._attachment_notified = False  # Reset so we can notify again on next attachment
 
     def start(self):
@@ -309,9 +315,11 @@ def _handle_process_death(self):
         self._module_base = None
         self._max_health_initialized = False
         self._current_health_initialized = False
+        self._potion_count_initialized = False
         self._process_id = None
         self._last_max_health_chain = None
         self._last_current_health_chain = None
+        self._last_potion_chain = None
         self._attachment_notified = False
         if self._process_running:
             self.process_died.emit()
@@ -551,6 +559,69 @@ def _initialize_current_health_pointer(self):
         except Exception as e:
             print(f"[ERROR] Error initializing current health pointer: {e}")
 
+    def _initialize_potion_pointer(self):
+        """
+        Initialize and print potion pointer debug information once.
+        Prints all debug info when first successfully reading potion count.
+        """
+        if self._potion_count_initialized:
+            return
+        
+        current_time = time.time()
+        if current_time - self._last_chain_resolution_attempt < self._chain_resolution_cooldown:
+            return
+        self._last_chain_resolution_attempt = current_time
+        
+        try:
+            if self._pm is None or self._module_base is None:
+                return
+            
+            print("Potion pointer:")
+            print(f"[OK] Module: {self.process_name} | Base address: {hex(self._module_base)}")
+            
+            base_offset_str = self.config.get_potion_base_offset()
+            offsets_str = self.config.get_potion_offsets()
+            
+            base_offset = parse_address(base_offset_str)
+            if base_offset == 0:
+                print("[ERROR] Invalid potion base offset")
+                return
+            
+            offsets = parse_offsets(offsets_str)
+            if not offsets:
+                print("[ERROR] Invalid potion offsets")
+                return
+            
+            base_address = self._module_base + base_offset
+            
+            try:
+                final_address, chain_addresses = read_pointer_chain(self._pm, base_address, offsets, return_chain=True)
+                
+                current_pointer_path = tuple(chain_addresses[:-1])
+                if self._last_potion_chain != current_pointer_path:
+                    print("[DEBUG] Potion pointer chain resolved:")
+                    print(f"  Step 0: addr=0x{chain_addresses[0]:X}")
+                    for i, (addr, offset) in enumerate(zip(chain_addresses[1:], offsets), 1):
+                        print(f"  Step {i}: addr=0x{addr:X} offset=0x{offset:X}")
+                    self._last_potion_chain = current_pointer_path
+                
+                print(f"[OK] Final address: {hex(final_address)}")
+            except RuntimeError as e:
+                print(f"[ERROR] {e}")
+                return
+            
+            try:
+                potion_count = read_memory_int(self._pm, final_address)
+                if potion_count >= 0:
+                    print(f"[RESULT] Player Potion Count: {potion_count}")
+                    self._potion_count_initialized = True
+                    print("-------------")
+            except Exception as e:
+                print(f"[ERROR] Failed to read final int value: {e}")
+                
+        except Exception as e:
+            print(f"[ERROR] Error initializing potion pointer: {e}")
+    
     def _read_current_health(self) -> float:
         """
         Read current health using pointer chain.
@@ -605,14 +676,46 @@ def _read_current_health(self) -> float:
 
     def _read_potion_count(self) -> int:
         """
-        Placeholder for reading potion count.
-        Currently returns 0 and does not affect the program.
+        Read potion count using pointer chain.
         
         Returns:
-            Potion count (int)
+            Potion count (int >= 0) on success, -1 on read failure
         """
-        # Placeholder - not implemented yet
-        return 0
+        try:
+            if self._pm is None or self._module_base is None:
+                return -1
+            
+            if not self._potion_count_initialized:
+                self._initialize_potion_pointer()
+            
+            base_offset_str = self.config.get_potion_base_offset()
+            offsets_str = self.config.get_potion_offsets()
+            
+            base_offset = parse_address(base_offset_str)
+            if base_offset == 0:
+                return -1
+            
+            offsets = parse_offsets(offsets_str)
+            if not offsets:
+                return -1
+            
+            base_address = self._module_base + base_offset
+            
+            final_address = read_pointer_chain(self._pm, base_address, offsets)
+            
+            potion_count = read_memory_int(self._pm, final_address)
+            if potion_count < 0:
+                return -1
+            return potion_count
+        except RuntimeError:
+            return -1
+        except Exception as e:
+            if not self._potion_count_initialized:
+                current_time = time.time()
+                if current_time - self._last_error_print_time >= self._error_print_cooldown:
+                    print(f"[ERROR] Error reading potion count: {e}")
+                    self._last_error_print_time = current_time
+            return -1
 
     def _use_potion(self):
         """Send potion keypress. Ensures game window is focused first."""
@@ -661,14 +764,18 @@ def _reading_loop(self):
                     # Emit signal for overlay to update display
                     self.current_health_updated.emit(current_health)
 
+                # Read potion count using pointer chain
+                potion_count = self._read_potion_count()
+                self.potion_count_updated.emit(potion_count)
+                
                 # Potion logic
-                if max_health > 0 and current_health >= 0:
+                if max_health > 0 and current_health >= 0 and potion_count > 0:
                     threshold_percentage = self.config.get_health_threshold()
                     threshold_value = (max_health * threshold_percentage) / 100.0
                     current_time = time.time()
                     time_since_last_potion = current_time - self._last_potion_time
 
-                    # Check if health is below threshold
+                    # Check if health is below threshold and player has potions
                     if current_health < threshold_value:
                         # Potion logic: wait 500ms between potion drinks
                         if time_since_last_potion >= self._potion_cooldown:
@@ -682,7 +789,8 @@ def _reading_loop(self):
                             # Print to console with same format as overlay
                             timestamp = datetime.now().strftime("%H:%M:%S")
                             health_amount = int(current_health)
-                            print(f"[LOG] {timestamp} - {health_amount} - {health_percentage:.1f}%")
+                            remaining = potion_count - 1
+                            print(f"[LOG] {timestamp} - {health_amount} - {health_percentage:.1f}% - {remaining} potions remaining")
 
                 # Check every 10ms
                 time.sleep(self.MEMORY_READ_INTERVAL)

src/main.py

@@ -31,6 +31,7 @@ def __init__(self, config, parent=None):
         self._potion_log: List[Dict] = []  # List of {timestamp, health_amount, percentage}
         self._current_health = 0.0
         self._max_health = 0.0
+        self._potion_count = -1  # Sentinel for unknown/failed read
 
         self._init_ui()
         self._setup_window_properties()
@@ -48,6 +49,11 @@ def _init_ui(self):
         self._update_status_display()
         layout.addWidget(self.status_label)
 
+        # Potions label
+        self.potions_label = QLabel("Potions: --")
+        self.potions_label.setStyleSheet("font-size: 12px; color: #CCCCCC; background-color: transparent;")
+        layout.addWidget(self.potions_label)
+        
         # Combined health label
         self.health_label = QLabel("Health: -- | --")
         self.health_label.setStyleSheet("font-size: 12px; color: #CCCCCC; background-color: transparent;")
@@ -207,6 +213,23 @@ def set_max_health(self, max_health: float):
         self._max_health = max_health if max_health > 0 else 0.0
         self._update_health_display()
 
+    def _update_potion_display(self):
+        """Update the potions label."""
+        if self._potion_count < 0:
+            self.potions_label.setText("Potions: --")
+        else:
+            self.potions_label.setText(f"Potions: {self._potion_count}")
+    
+    def set_potion_count(self, value: int):
+        """
+        Update potion count display.
+        
+        Args:
+            value: Potion count (>= 0) or sentinel (< 0) for read failure
+        """
+        self._potion_count = value
+        self._update_potion_display()
+    
     def add_potion_log_entry(self, health_amount: float, percentage: float):
         """
         Add entry to potion log.