PyDmGame

https://github.com/xiong421/pydmgame
Admin
PyDmGame is a Python library for game automation that provides window binding, image recognition,...
Tokens:9,678
Snippets:39
Trust Score:5.1
Update:9 months ago
Show doc for...
Tokens:
Raw
### Activate and Restore Window

Source: https://context7.com/xiong421/pydmgame/llms.txt

Brings a specified window to the foreground and restores it if minimized. This is a fundamental operation for user interaction simulation.

```python
import PyDmGame

dm = PyDmGame.DM()
hwnd = dm.FindWindow("Notepad", "")

# Activate and restore the window
dm.SetWindowState(hwnd, 4)
```

--------------------------------

### Initialize and Bind Window with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Initializes the PyDmGame DM object, sets an optional image search path, and binds to a target window using specified input/output modes. This is the first step before interacting with any window.

```python
import PyDmGame

# Initialize the DM object
dm = PyDmGame.DM()

# Set default image search path (optional)
dm.SetPath("/path/to/images")

# Bind to a window with specified modes
# hwnd: window handle (use Window.FindWindow to get it)
# display: "normal" (foreground) or "gdi" (background GDI mode)
# mouse: "normal", "normal2", "windows", or "windows2"
# keypad: "normal", "normal2", "windows", or "windows2"
hwnd = 657562  # Example window handle
dm.BindWindow(hwnd, "normal", "normal", "windows", 0)
```

--------------------------------

### Keyboard Input Simulation

Source: https://context7.com/xiong421/pydmgame/llms.txt

Simulates keyboard input by pressing keys, typing strings, or controlling key states, using different backend methods.

```APIDOC
## Keyboard Input Simulation

### Description
Send keyboard input to windows using various backend methods.

### Methods
- `KeyPressChar(key)`: Simulates pressing and releasing a single key (virtual key code or character).
- `KeyPressStr(string, delay)`: Types a string with a specified delay between each character.
- `KeyDownChar(key)`: Simulates pressing down a key without releasing it.
- `KeyUpChar(key)`: Simulates releasing a key that was previously pressed down.
- `SendString(hwnd, str)`: Sends a string directly to a specified window.
- `SetKeypadDelay(delay)`: Sets the delay between keyboard key presses.

### Request Example
```python
import PyDmGame
import time

dm = PyDmGame.DM()
dm.BindWindow(hwnd, "normal", "normal", "windows", 0)

# Type a string with delay
dm.KeyPressStr("hello123", 50)

# Press and release specific keys
dm.KeyPressChar("enter")

# Simulate holding shift while typing 'A'
dm.KeyDownChar("shift")
dm.KeyPressChar("a")
dm.KeyUpChar("shift")

# Send string directly to window
dm.SendString(hwnd, "Direct text input!")

# Set keyboard delay
dm.SetKeypadDelay(30)
```

### Response
These methods typically do not return specific values indicating success or failure, but rather perform the simulated keyboard action.
```

--------------------------------

### Simulate Keyboard Input with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Provides methods to simulate keyboard input, including pressing individual keys, typing strings with delays, and manual key control (down/up). It also supports sending text directly to a window. Requires PyDmGame.

```python
import PyDmGame
import time

dm = PyDmGame.DM()
dm.BindWindow(hwnd, "normal", "normal", "windows", 0)

# Press single key (virtual key code)
dm.KeyPressChar("a")
dm.KeyPressChar("enter")
dm.KeyPressChar("ctrl")

# Type string sequence with delay between each key
# delay: milliseconds between each keypress
dm.KeyPressStr("hello123", 50)

# Manual key control
dm.KeyDownChar("shift")
dm.KeyPressChar("a")
dm.KeyUpChar("shift")

# Send text directly to window (alternative method)
dm.SendString(hwnd, "Hello World!")

# Set keyboard delay (advanced timing control)
dm.SetKeypadDelay(30)  # 30ms delay
```

--------------------------------

### Process and Window Enumeration using PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Enumerates running processes by name and retrieves their information, and lists windows based on specified criteria like title or class. Useful for dynamically identifying and selecting target windows for automation.

```python
import PyDmGame

dm = PyDmGame.DM()

# Enumerate all processes by name (requires psutil)
pids = dm.EnumProcess("chrome.exe")
print(f"Chrome processes: {pids}")

# Get process information
pid_list = pids.split(',')
if pid_list and pid_list[0]:
    first_pid = int(pid_list[0])
    info = dm.GetProcessInfo(first_pid)
    print(f"Process info: {info}")

# Enumerate windows by criteria
parent = 0  # 0 for desktop
title = "Chrome"
class_name = ""
filter_flags = 1 | 16  # Match title and visible only

try:
    windows = dm.EnumWindow(parent, title, class_name, filter_flags)
    print(f"Matching windows: {windows}")

    # Convert to list and process
    hwnd_list = [int(h) for h in windows.split(',')] if windows else []
    for hwnd in hwnd_list:
        print(f"  Window {hwnd}: {dm.GetWindowTitle(hwnd)}")
except Exception as e:
    print(f"No windows found: {e}")
```

--------------------------------

### Window Information Retrieval

Source: https://context7.com/xiong421/pydmgame/llms.txt

Retrieves various properties of windows, including their title, class name, process ID, executable path, and screen coordinates.

```APIDOC
## Window Information Retrieval

### Description
Query window properties including title, class, position, and process information.

### Methods
- `GetForegroundWindow()`: Returns the handle of the currently active window.
- `GetMousePointWindow()`: Returns the handle of the window under the current mouse cursor position.
- `GetWindowTitle(hwnd)`: Returns the title of the specified window.
- `GetWindowClass(hwnd)`: Returns the class name of the specified window.
- `GetWindowProcessId(hwnd)`: Returns the process ID (PID) of the specified window.
- `GetWindowProcessPath(hwnd)`: Returns the full path to the executable of the specified window's process.
- `GetWindowRect(hwnd)`: Returns the screen coordinates (x1, y1, x2, y2) of the specified window's bounding rectangle.
- `GetClientSize(hwnd)`: Returns the width and height of the client area of the specified window.

### Request Example
```python
import PyDmGame

dm = PyDmGame.DM()

# Get foreground window handle
active_hwnd = dm.GetForegroundWindow()
print(f"Active window handle: {active_hwnd}")

# Get window handle under mouse
dm.MoveTo(400, 300) # Move mouse to simulate
hwnd_at_mouse = dm.GetMousePointWindow()
print(f"Window under mouse handle: {hwnd_at_mouse}")

# Get properties of a window
title = dm.GetWindowTitle(hwnd_at_mouse)
class_name = dm.GetWindowClass(hwnd_at_mouse)
pid = dm.GetWindowProcessId(hwnd_at_mouse)
process_path = dm.GetWindowProcessPath(hwnd_at_mouse) # Requires psutil

print(f"Title: {title}")
print(f"Class: {class_name}")
print(f"PID: {pid}")
print(f"Path: {process_path}")

# Get window rectangle and client size
x1, y1, x2, y2 = dm.GetWindowRect(hwnd_at_mouse)
print(f"Window rect: ({x1}, {y1}, {x2}, {y2})")
width, height = dm.GetClientSize(hwnd_at_mouse)
print(f"Client size: {width}x{height}")
```

### Response
- **hwnd**: Window handle (integer).
- **title**: Window title (string).
- **class_name**: Window class name (string).
- **pid**: Process ID (integer).
- **process_path**: Full path to the process executable (string).
- **x1, y1, x2, y2**: Screen coordinates (integers).
- **width, height**: Client area dimensions (integers).
```

--------------------------------

### Window State Control

Source: https://context7.com/xiong421/pydmgame/llms.txt

Manipulates the state of a window, including minimizing, maximizing, restoring, setting topmost, moving, resizing, and changing transparency.

```APIDOC
## Window State Control

### Description
Manipulate window visibility, position, and activation state.

### Methods
- `FindWindow(class_name, window_title)`: Finds a window by its class name and title.
- `GetWindowState(hwnd, state_type)`: Retrieves the current state of a window (e.g., visible, minimized, maximized).
- `SetWindowState(hwnd, state)`: Sets the state of a window (e.g., restore, minimize, maximize, topmost).
- `MoveWindow(hwnd, x, y)`: Moves the specified window to new coordinates.
- `SetWindowSize(hwnd, width, height)`: Resizes the specified window.
- `SetWindowText(hwnd, new_title)`: Changes the title of the specified window.
- `SetWindowTransparent(hwnd, transparency)`: Sets the transparency level of the window.

### Parameters for `GetWindowState`
- **state_type**: Integer representing the state to check:
    - `2`: Is window visible?
    - `3`: Is window minimized?
    - `4`: Is window maximized?

### Parameters for `SetWindowState`
- **state**: Integer representing the state to set:
    - `5`: Restore window.
    - `6`: Minimize window.
    - `7`: Maximize window.
    - `8`: Set window to be topmost.
    - `9`: Cancel topmost.
    - `11`: Activate and show window.

### Request Example
```python
import PyDmGame

dm = PyDmGame.DM()
hwnd = dm.FindWindow("", "Calculator") # Example: Find Calculator window

if hwnd:
    # Check current states
    is_visible = dm.GetWindowState(hwnd, 2)
    is_minimized = dm.GetWindowState(hwnd, 3)
    print(f"Visible: {is_visible}, Minimized: {is_minimized}")

    # Maximize the window
    dm.SetWindowState(hwnd, 7)
    time.sleep(1)

    # Restore and move the window
    dm.SetWindowState(hwnd, 5)
    dm.MoveWindow(hwnd, 100, 100)
    time.sleep(1)

    # Resize the window
    dm.SetWindowSize(hwnd, 800, 600)
    time.sleep(1)

    # Set window to be topmost
    dm.SetWindowState(hwnd, 8)
    dm.SetWindowText(hwnd, "My Calculator")
    dm.SetWindowTransparent(hwnd, 200) # Make it semi-transparent
else:
    print("Calculator window not found.")
```

### Response
- **GetWindowState**: Returns `1` if the state is true, `0` otherwise.
- Other methods generally do not return specific values but perform actions.
```

--------------------------------

### Retrieve Window Information with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Queries various properties of windows, including their titles, class names, process IDs and paths, screen coordinates, and client area dimensions. Requires PyDmGame and optionally `psutil` for process path retrieval.

```python
import PyDmGame

dm = PyDmGame.DM()

# Get foreground window
active_hwnd = dm.GetForegroundWindow()
print(f"Active window: {active_hwnd}")

# Get window at mouse position
dm.MoveTo(400, 300)
hwnd_at_mouse = dm.GetMousePointWindow()
print(f"Window under mouse: {hwnd_at_mouse}")

# Get window properties
title = dm.GetWindowTitle(hwnd_at_mouse)
class_name = dm.GetWindowClass(hwnd_at_mouse)
pid = dm.GetWindowProcessId(hwnd_at_mouse)
process_path = dm.GetWindowProcessPath(hwnd_at_mouse)  # Requires psutil

print(f"Title: {title}")
print(f"Class: {class_name}")
print(f"PID: {pid}")
print(f"Path: {process_path}")

# Get window rectangle coordinates (screen space)
x1, y1, x2, y2 = dm.GetWindowRect(hwnd_at_mouse)
print(f"Window rect: ({x1}, {y1}, {x2}, {y2})")

# Get client area size
width, height = dm.GetClientSize(hwnd_at_mouse)
print(f"Client size: {width}x{height}")
```

--------------------------------

### Mouse Movement and Clicks

Source: https://context7.com/xiong421/pydmgame/llms.txt

Simulates mouse cursor movements and various click actions (left, right, double click, press/hold) in foreground or background modes.

```APIDOC
## Mouse Movement and Clicks

### Description
Move mouse cursor and perform click operations in foreground or background modes.

### Methods
- `MoveTo(x, y)`: Moves the mouse cursor to the specified coordinates.
- `LeftClick()`: Performs a single left mouse click.
- `LeftDoubleClick()`: Performs a double left mouse click.
- `RightClick()`: Performs a single right mouse click.
- `LeftDown()`: Presses and holds the left mouse button.
- `LeftUp()`: Releases the left mouse button.
- `WheelUp()`: Simulates scrolling the mouse wheel up.
- `WheelDown()`: Simulates scrolling the mouse wheel down.
- `SetMouseDelay(mode, delay)`: Sets the delay between mouse down and up events.

### Request Example
```python
import PyDmGame
import time

dm = PyDmGame.DM()
dm.BindWindow(hwnd, "normal", "windows", "windows", 0)

# Move mouse to coordinates
dm.MoveTo(500, 300)
time.sleep(0.1)

# Single left click
dm.LeftClick()

# Move and click
dm.MoveTo(600, 400)
dm.LeftClick()

# Mouse wheel operations
dm.WheelUp()
dm.WheelDown()

# Set mouse delay
dm.SetMouseDelay("windows", 50)
```

### Response
These methods typically do not return specific values indicating success or failure, but rather perform the action.
```

--------------------------------

### Control Window State and Appearance with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Allows manipulation of window states such as visibility, minimized, maximized, and topmost status. It can also be used to move, resize, set the title, and adjust the transparency of a window. Requires PyDmGame.

```python
import PyDmGame

dm = PyDmGame.DM()
hwnd = dm.FindWindow("", "Calculator")

# Check window state
is_visible = dm.GetWindowState(hwnd, 2)  # 2 = check if visible
is_minimized = dm.GetWindowState(hwnd, 3)  # 3 = check if minimized
is_maximized = dm.GetWindowState(hwnd, 4)  # 4 = check if maximized

print(f"Visible: {is_visible}, Minimized: {is_minimized}, Maximized: {is_maximized}")

# Set window state
dm.SetWindowState(hwnd, 5)  # 5 = restore window
dm.SetWindowState(hwnd, 8)  # 8 = set topmost
dm.SetWindowState(hwnd, 9)  # 9 = cancel topmost

# Move window position
dm.MoveWindow(hwnd, 100, 100)

# Resize window
dm.SetWindowSize(hwnd, 800, 600)

# Set window title
dm.SetWindowText(hwnd, "New Window Title")

# Set transparency (0-255, 0=invisible, 255=opaque)
dm.SetWindowTransparent(hwnd, 200)
```

--------------------------------

### Find Multiple Images

Source: https://context7.com/xiong421/pydmgame/llms.txt

Locates all occurrences of a template image within a specified screen region and returns their coordinates.

```APIDOC
## Find Multiple Images

### Description
Locate all occurrences of a template image within a screen region.

### Method
`FindPics`

### Parameters
- **hwnd**: The window handle to search within.
- **mode**: The image searching mode (e.g., `0` for normal).
- **x1, y1, x2, y2**: The coordinates defining the search region.
- **image_name**: The filename of the template image.
- **color_format**: Color format for searching (can be empty).
- **similarity**: The similarity threshold (0.0 to 1.0).
- **count**: The maximum number of matches to find.

### Request Example
```python
import PyDmGame

dm = PyDmGame.DM()
dm.SetPath("/path/to/images")
dm.BindWindow(hwnd, "gdi", "windows", "windows", 0)

status, locations = dm.FindPics(0, 0, 1920, 1080, "coin.bmp", "", 0.85, 5)

if status == 0:
    print(f"Found {len(list(locations))} matches:")
    for idx, (x, y) in enumerate(locations):
        print(f"  Match {idx+1}: ({x}, {y})")
else:
    print("No matches found")
```

### Response
- **status**: An integer indicating the result of the operation (0 for success).
- **locations**: A list of tuples, where each tuple contains the (x, y) coordinates of a found image match.
```

--------------------------------

### Find Window Handles by Title/Class/Process with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Locates window handles using window class name, title, or process name. It also provides functions to retrieve window title, class name, and process ID. These handles are essential for binding operations.

```python
import PyDmGame

dm = PyDmGame.DM()

# Find window by class and title (partial match supported)
hwnd = dm.FindWindow("Notepad", "Untitled")
print(f"Window handle: {hwnd}")

# Find window by process name
hwnd = dm.FindWindowByProcess("notepad.exe", "", "")
print(f"Found window: {hwnd}")

# Get window information
title = dm.GetWindowTitle(hwnd)
class_name = dm.GetWindowClass(hwnd)
pid = dm.GetWindowProcessId(hwnd)
print(f"Title: {title}, Class: {class_name}, PID: {pid}")
```

--------------------------------

### Screen Capture with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Captures a specified region of the bound window into memory, which can then be retrieved as an OpenCV image or saved to a file. Supports capturing the entire window or a custom rectangle.

```python
import PyDmGame
import cv2

dm = PyDmGame.DM()
dm.BindWindow(hwnd, "gdi", "windows", "windows", 0)

# Capture entire window (use 0,0,0,0 for full window)
dm.Capture(0, 0, 0, 0)

# Get the captured image as OpenCV format
img = dm.GetCVImg()
cv2.imshow("Captured", img)
cv2.waitKey(0)

# Capture specific region and save to file
dm.Capture(100, 100, 500, 400, "/path/to/screenshot.png")
```

--------------------------------

### Simulate Mouse Movements and Clicks with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Enables programmatic control of mouse cursor movements and click actions, including single clicks, double clicks, right clicks, and click-and-hold operations. Supports foreground and background modes. Requires PyDmGame.

```python
import PyDmGame
import time

dm = PyDmGame.DM()
dm.BindWindow(hwnd, "normal", "windows", "windows", 0)

# Move mouse to coordinates
dm.MoveTo(500, 300)
time.sleep(0.1)

# Single left click
dm.LeftClick()

# Double click
dm.LeftDoubleClick()

# Right click
dm.RightClick()

# Manual control: press and hold
dm.LeftDown()
time.sleep(1)
dm.LeftUp()

# Mouse wheel operations
dm.WheelUp()    # Scroll up
dm.WheelDown()  # Scroll down

# Set mouse delay for click timing (advanced)
dm.SetMouseDelay("windows", 50)  # 50ms delay between down and up
```

--------------------------------

### Coordinate Conversion using PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Converts coordinates between a window's client area and the screen, and retrieves the client area's dimensions. Essential for precise mouse control within a window, especially in background mode.

```python
import PyDmGame

dm = PyDmGame.DM()
hwnd = dm.FindWindow("Notepad", "")

# Convert client coordinates to screen coordinates
screen_x, screen_y = dm.ClientToScreen(hwnd, 50, 100)
print(f"Client (50, 100) -> Screen ({screen_x}, {screen_y})")

# Convert screen coordinates back to client coordinates
client_x, client_y = dm.ScreenToClient(hwnd, screen_x, screen_y)
print(f"Screen ({screen_x}, {screen_y}) -> Client ({client_x}, {client_y})")

# Get client rectangle in screen coordinates
x1, y1, x2, y2 = dm.GetClientRect(hwnd)
print(f"Client area in screen coords: ({x1}, {y1}, {x2}, {y2})")

# Example of using coordinates for clicking
dm.BindWindow(hwnd, "gdi", "windows", "windows", 0)
target_x, target_y = 100, 200  # Client coordinates
dm.MoveTo(target_x, target_y)
dm.LeftClick()
```

--------------------------------

### Virtual Key Codes Mapping (Python)

Source: https://github.com/xiong421/pydmgame/blob/master/README.md

This Python dictionary maps common key names to their corresponding virtual key codes. These codes are essential for simulating keyboard input in applications or games.

```python
'backspace': 0x08,
    'tab': 0x09,
    'clear': 0x0C,
    'enter': 0x0D,
    'shift': 0x10,
    'ctrl': 0x11,
    'alt': 0x12,
    'pause': 0x13,
    'caps_lock': 0x14,
    'esc': 0x1B,
    'spacebar': 0x20,
    'page_up': 0x21,
    'page_down': 0x22,
    'end': 0x23,
    'home': 0x24,
    'left_arrow': 0x25,
    'up_arrow': 0x26,
    'right_arrow': 0x27,
    'down_arrow': 0x28,
    'select': 0x29,
    'print': 0x2A,
    'execute': 0x2B,
    'print_screen': 0x2C,
    'ins': 0x2D,
    'del': 0x2E,
    'help': 0x2F,
    '0': 0x30,
    '1': 0x31,
    '2': 0x32,
    '3': 0x33,
    '4': 0x34,
    '5': 0x35,
    '6': 0x36,
    '7': 0x37,
    '8': 0x38,
    '9': 0x39,
    'a': 0x41,
    'b': 0x42,
    'c': 0x43,
    'd': 0x44,
    'e': 0x45,
    'f': 0x46,
    'g': 0x47,
    'h': 0x48,
    'i': 0x49,
    'j': 0x4A,
    'k': 0x4B,
    'l': 0x4C,
    'm': 0x4D,
    'n': 0x4E,
    'o': 0x4F,
    'p': 0x50,
    'q': 0x51,
    'r': 0x52,
    's': 0x53,
    't': 0x54,
    'u': 0x55,
    'v': 0x56,
    'w': 0x57,
    'x': 0x58,
    'y': 0x59,
    'z': 0x5A,
    'numpad_0': 0x60,
    'numpad_1': 0x61,
    'numpad_2': 0x62,
    'numpad_3': 0x63,
    'numpad_4': 0x64,
    'numpad_5': 0x65,
    'numpad_6': 0x66,
    'numpad_7': 0x67,
    'numpad_8': 0x68,
    'numpad_9': 0x69,
    'multiply_key': 0x6A,
    'add_key': 0x6B,
    'separator_key': 0x6C,
    'subtract_key': 0x6D,
    'decimal_key': 0x6E,
    'divide_key': 0x6F,
    'f1': 0x70,
    'f2': 0x71,
    'f3': 0x72,
    'f4': 0x73,
    'f5': 0x74,
    'f6': 0x75,
    'f7': 0x76,
    'f8': 0x77,
    'f9': 0x78,
    'f10': 0x79,
    'f11': 0x7A,
    'f12': 0x7B,
    'f13': 0x7C,
    'f14': 0x7D,
    'f15': 0x7E,
    'f16': 0x7F,
    'f17': 0x80,
    'f18': 0x81,
    'f19': 0x82,
    'f20': 0x83,
    'f21': 0x84,
    'f22': 0x85,
    'f23': 0x86,
    'f24': 0x87,
    'num_lock': 0x90,
    'scroll_lock': 0x91,
    'left_shift': 0xA0,
    'right_shift ': 0xA1,
    'left_control': 0xA2,
    'right_control': 0xA3,
    'left_menu': 0xA4,
    'right_menu': 0xA5,
    'browser_back': 0xA6,
    'browser_forward': 0xA7,
    'browser_refresh': 0xA8,
    'browser_stop': 0xA9,
    'browser_search': 0xAA,
    'browser_favorites': 0xAB,
    'browser_start_and_home': 0xAC,
    'volume_mute': 0xAD,
    'volume_Down': 0xAE,
    'volume_up': 0xAF,
    'next_track': 0xB0,
    'previous_track': 0xB1,
    'stop_media': 0xB2,
    'play/pause_media': 0xB3,
    'start_mail': 0xB4,
    'select_media': 0xB5,
    'start_application_1': 0xB6,
    'start_application_2': 0xB7,
    'attn_key': 0xF6,
    'crsel_key': 0xF7,
    'exsel_key': 0xF8,
    'play_key': 0xFA,
    'zoom_key': 0xFB,
    'clear_key': 0xFE,
    '+': 0xBB,
    ',': 0xBC,
    '-': 0xBD,
    '.': 0xBE,
    '/': 0xBF,
    '`': 0xC0,
    ';': 0xBA,
    '[': 0xDB,
    '\': 0xDC,
    ']': 0xDD,
    "'" : 0xDE}
```

--------------------------------

### Find Multiple Images in Region using PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Locates all occurrences of a template image within a specified screen region. It returns the status of the operation and a list of coordinates for each match found. Requires the PyDmGame library and template image files.

```python
import PyDmGame

dm = PyDmGame.DM()
dm.SetPath("/path/to/images")
dm.BindWindow(hwnd, "gdi", "windows", "windows", 0)

# Find all matching images
# Returns: (status, [(x1,y1), (x2,y2), ...])
status, locations = dm.FindPics(0, 0, 1920, 1080, "coin.bmp", "", 0.85, 5)

if status == 0:
    print(f"Found {len(list(locations))}" matches:")
    for idx, (x, y) in enumerate(locations):
        print(f"  Match {idx+1}: ({x}, {y})")
        # Click each found location
        dm.MoveTo(x, y)
        dm.LeftClick()
        import time
        time.sleep(0.5)
else:
    print("No matches found")
```

--------------------------------

### Find Image Template with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Locates a template image (e.g., a button or icon) within a specified screen region using OpenCV's template matching algorithms. It returns the coordinates of the top-left corner of the found image and can optionally apply color filtering.

```python
import PyDmGame

dm = PyDmGame.DM()
dm.SetPath("/path/to/image/folder")
dm.BindWindow(hwnd, "normal", "normal", "normal", 0)

# Find image using template matching
# method: 0-5 (default 5 for normalized correlation coefficient)
# delta_color: RGB offset "FFFFFF-202020" or HSV ((0,0,0),(180,255,255))
# sim: similarity threshold (interpretation depends on method)
status, x, y = dm.FindPic(0, 0, 960, 540, "button.bmp", "FFFFFF-303030", 0.9, 5)

if status == 0:
    print(f"Image found at top-left corner: ({x}, {y})")
    # Click on the found image
    dm.MoveTo(x + 10, y + 10)
    dm.LeftClick()
else:
    print("Image not found")

# HSV color filtering for better matching
status, x, y = dm.FindPic(0, 0, 960, 540, "icon.bmp", ((0, 0, 221), (180, 30, 255)), 0.85, 5, True)
```

--------------------------------

### Compare Color at Point with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Compares the color at a specific coordinate (x, y) against an expected color value within a given tolerance and similarity threshold. Returns a boolean indicating if the color matches.

```python
import PyDmGame

dm = PyDmGame.DM()
dm.BindWindow(hwnd, "normal", "normal", "normal", 0)

# Compare color at point (x=100, y=200)
# Color format: "RRGGBB-DRDGDB" where DR,DG,DB are tolerance values
# Similarity: 0.1-1.0 (1.0 = exact match, 0.9 = 90% similar)
is_match = dm.CmpColor(100, 200, "888888-505050", 0.9)

if is_match:
    print("Color matches at position (100, 200)")
else:
    print("Color does not match")

# Simple color check without tolerance
is_exact = dm.CmpColor(150, 250, "FF0000", 1.0)
print(f"Exact red color: {is_exact}")
```

--------------------------------

### OCR Number Recognition using PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Recognizes numeric digits from specified screen regions using template matching with pre-defined digit images (0.bmp to 9.bmp). It can also check for the existence of a specific number sequence within a region. Requires PyDmGame and digit template images.

```python
import PyDmGame

dm = PyDmGame.DM()
dm.SetPath("/path/to/project")
dm.BindWindow(hwnd, "gdi", "windows", "windows", 0)

# Recognize numbers using digit templates (0.bmp through 9.bmp)
# dirPath should contain template images: 0.bmp, 1.bmp, ..., 9.bmp
# color_format: color filtering (can be empty "")
# sim: similarity threshold (0.1-1.0)
recognized_number = dm.OcrNum(100, 100, 300, 150, "", 0.95, "digit_templates")

if recognized_number:
    print(f"Recognized number: {recognized_number}")
    # Convert to integer if needed
    try:
        num_value = int(recognized_number)
        print(f"Numeric value: {num_value}")
    except ValueError:
        print("Could not convert to integer")

# Check if specific number exists in region
exists = dm.FindNum(100, 100, 300, 150, "123", "", 0.9)
print(f"Number '123' exists: {exists}")
```

--------------------------------

### OCR Number Recognition

Source: https://context7.com/xiong421/pydmgame/llms.txt

Recognizes numeric digits from screen regions using template matching with pre-defined digit images (0.bmp to 9.bmp).

```APIDOC
## OCR Number Recognition

### Description
Recognize numeric digits from screen regions using template matching with digit images.

### Methods
- `OcrNum(x1, y1, x2, y2, color_format, similarity, dirPath)`: Recognizes numbers within a specified region using digit templates.
- `FindNum(x1, y1, x2, y2, number_string, color_format, similarity)`: Checks if a specific number string exists within a region.

### Parameters for `OcrNum`
- **x1, y1, x2, y2**: Coordinates defining the region to scan for numbers.
- **color_format**: Color filtering string (can be empty).
- **similarity**: The similarity threshold for matching digit templates (0.1-1.0).
- **dirPath**: The directory containing the digit template images (e.g., "0.bmp" through "9.bmp").

### Parameters for `FindNum`
- **x1, y1, x2, y2**: Coordinates defining the region to scan.
- **number_string**: The specific number string to search for.
- **color_format**: Color filtering string (can be empty).
- **similarity**: The similarity threshold for matching (0.0 to 1.0).

### Request Example
```python
import PyDmGame

dm = PyDmGame.DM()
dm.SetPath("/path/to/project")
dm.BindWindow(hwnd, "gdi", "windows", "windows", 0)

# Recognize numbers in a region
recognized_number = dm.OcrNum(100, 100, 300, 150, "", 0.95, "digit_templates")

if recognized_number:
    print(f"Recognized number: {recognized_number}")
    try:
        num_value = int(recognized_number)
        print(f"Numeric value: {num_value}")
    except ValueError:
        print("Could not convert to integer")

# Check if a specific number exists
exists = dm.FindNum(100, 100, 300, 150, "123", "", 0.9)
print(f"Number '123' exists: {exists}")
```

### Response
- `OcrNum`: Returns the recognized number as a string, or an empty string if no number is recognized.
- `FindNum`: Returns `1` if the number exists, `0` otherwise.
```

--------------------------------

### Find Color in Region with PyDmGame

Source: https://context7.com/xiong421/pydmgame/llms.txt

Searches for a specific color within a defined rectangular region on the screen. It returns the coordinates of the first matching pixel found or indicates if no match was found. Supports both RGB and HSV color formats.

```python
import PyDmGame

dm = PyDmGame.DM()
dm.BindWindow(hwnd, "gdi", "windows", "windows", 0)

# Find yellow color in full screen region
# Color format: "RRGGBB-DRDGDB"
# Returns: (status, x, y) where status=0 if found, -1 if not found
status, x, y = dm.FindColor(0, 0, 1920, 1080, "ffff00-404040", 0.95)

if status == 0:
    print(f"Yellow color found at ({x}, {y})")
else:
    print("Color not found in region")

# HSV color search format: ((H_min, S_min, V_min), (H_max, S_max, V_max))
status, x, y = dm.FindColor(0, 0, 1920, 1080, ((20, 100, 100), (30, 255, 255)), 0.9)
if status == 0:
    print(f"HSV color match at ({x}, {y})")
```
Tokens:
Raw