Créez vos propres bots Python avec PyAutoGUI : Un guide complet

L’automatisation est devenue un outil essentiel dans notre monde numérique en constante évolution.

Que vous soyez un développeur chevronné ou un débutant curieux, la création de bots peut grandement simplifier vos tâches quotidiennes et augmenter votre productivité.

Dans cet article, nous allons explorer comment créer des bots puissants en utilisant Python et la bibliothèque PyAutoGUI.

Introduction à PyAutoGUI

PyAutoGUI est une bibliothèque Python polyvalente qui permet d’automatiser les interactions avec votre ordinateur. Elle offre des fonctionnalités pour contrôler la souris, le clavier, et même pour effectuer des captures d’écran.

Dans ce tutoriel, nous allons couvrir les bases de PyAutoGUI et créer trois types de bots différents :

1. Un bot simple qui clique en fonction de la couleur d’un pixel
2. Un bot qui repère et clique sur des images à l’écran
3. Un bot avancé qui lit, comprend et agit en fonction du texte à l’écran

Prérequis

Avant de commencer, assurez-vous d’avoir Python installé sur votre machine. Si ce n’est pas le cas, rendez-vous sur python.org et téléchargez la dernière version. Lors de l’installation, n’oubliez pas de cocher la case pour ajouter Python au PATH.

Si vous voulez plus d’information sur l’installation de Python, alors mon article Comment installer Python vous intéressera sûrement !

Pour écrire notre code, vous pouvez utiliser l’éditeur de texte de votre choix. Si vous n’en avez pas, IDLE, qui vient avec Python, fera parfaitement l’affaire. Pour ceux qui souhaitent aller plus loin, je recommande Visual Studio Code ou PyCharm.

Là aussi, j’ai un article complet pour tout vous expliquer sur Visual Studio Code. Dedans, on voit ensemble comment l’installer et comment le prendre en main !

Installation de PyAutoGUI

Pour installer PyAutoGUI, ouvrez un terminal et tapez la commande suivante :

pip install pyautogui

Plus d’infos sur les terminaux sur Windows.

Vous aurez également besoin du module Pillow pour certaines fonctionnalités de capture d’écran. Installez-le avec :

pip install pillow

Les bases de PyAutoGUI

Commençons par explorer les fonctions les plus utiles de PyAutoGUI :

1. Importer le module PyAutoGUI

import pyautogui

2. Obtenir la taille de l’écran

print(pyautogui.size())

3. Obtenir la position actuelle du curseur

print(pyautogui.position())

4. Déplacer le curseur

pyautogui.moveTo(x, y, duration=1)  # Déplacement absolu
pyautogui.move(200, 200, duration=1)  # Déplacement relatif

5. Cliquer

pyautogui.click(x, y)
pyautogui.doubleClick(x, y)
pyautogui.rightClick(x, y)

6. Faire scroller la zone de votre curseur:

pyautogui.scroll(amount)  # Vertical
pyautogui.hscroll(amount)  # Horizontal

7. Saisir du texte et appuyer sur des touches :

pyautogui.write("Hello, World!")
pyautogui.press('enter')

8. Utiliser des combinaisons de touches :

with pyautogui.hold('ctrl'):
    pyautogui.press('c')

9. Capturer l’écran :

screenshot = pyautogui.screenshot(region=(x, y, width, height))
screenshot.save("capture.png")

10. Obtenir la couleur d’un pixel :

color = pyautogui.pixel(x, y)

Ces fonctions de base vous permettront de créer une grande variété de bots pour automatiser vos tâches quotidiennes.

Création du premier bot : Parcourir une grille de cases

Maintenant que nous avons vu les bases de PyAutoGUI, mettons nos connaissances en pratique avec un cas concret. Imaginons un site web où nous avons une grille de cases qui disparaissent lorsqu’on passe le curseur dessus. Notre objectif est de créer un bot qui parcourt toutes ces cases automatiquement.

Analyse du problème

Avant de nous lancer dans le code, décomposons le problème :

1. La grille est composée de 5 colonnes et 8 lignes.
2. Nous devons passer sur toutes les cases.
3. Nous avons le choix entre un parcours horizontal ou vertical.

Pour simplifier notre bot, nous opterons pour un parcours vertical, en descendant chaque colonne puis en passant à la suivante.

Récupération des coordonnées clés

Pour réaliser notre bot, nous avons besoin de trois informations cruciales :

1. Les coordonnées du centre de la première case (en haut à gauche)
2. La distance verticale entre la première et la dernière case d’une colonne
3. La distance horizontale entre deux cases adjacentes

Créons un fichier get_position.py pour nous aider à récupérer ces coordonnées :

import pyautogui
import time

time.sleep(2)  # Délai pour nous laisser le temps de positionner le curseur
print(pyautogui.position())

Utilisons ce script pour obtenir les coordonnées nécessaires, puis créons notre fichier principal move_mouse.py :

import pyautogui
import time

# Coordonnées initiales
origin = (x, y)  # Remplacez x et y par les valeurs obtenues

# Calcul des distances
distance_x = ...  # Distance horizontale entre deux cases
distance_y = ...  # Distance verticale totale d'une colonne

# Délai avant de commencer
time.sleep(2)

# Positionnement initial
pyautogui.moveTo(origin[0], origin[1])

# Parcours de la première colonne
pyautogui.move(0, distance_y, duration=0.7)

# Déplacement vers la droite
pyautogui.move(distance_x, 0, duration=0.1)

# Remontée de la colonne
pyautogui.move(0, -distance_y, duration=0.7)

# Répétez ces mouvements pour les colonnes restantes
# ...

Améliorations possibles

Ce code de base fonctionne, mais il peut être amélioré de plusieurs façons :

1. Utiliser des boucles pour réduire la répétition du code.
2. Calculer la distance_y à partir de distance_x, puisque les cases sont carrées.
3. Paramétrer le nombre de colonnes et de lignes pour rendre le script plus flexible.

Voici une version améliorée du script :

import pyautogui
import time

# Configuration
origin = (x, y)  # Coordonnées initiales
distance = ...  # Distance entre deux cases (horizontale ou verticale)
columns = 5
rows = 8

# Délai avant de commencer
time.sleep(2)

# Positionnement initial
pyautogui.moveTo(origin[0], origin[1])

# Parcours de la grille
for col in range(columns):
    if col % 2 == 0:
        # Descente
        pyautogui.move(0, distance * (rows - 1), duration=0.7)
    else:
        # Montée
        pyautogui.move(0, -distance * (rows - 1), duration=0.7)

    # Déplacement vers la droite (sauf pour la dernière colonne)
    if col < columns - 1:
        pyautogui.move(distance, 0, duration=0.1)

print("Parcours terminé !")

Ce script amélioré est plus flexible et plus facile à modifier pour différentes tailles de grilles.

Conclusion de cette première partie

Dans cette section, nous avons appris à :

1. Analyser un problème d’automatisation
2. Récupérer des coordonnées à l’écran
3. Utiliser les fonctions de base de PyAutoGUI pour déplacer la souris
4. Créer un script simple mais efficace pour parcourir une grille

Ce premier bot nous a permis de mettre en pratique les concepts de base de PyAutoGUI. Dans la prochaine partie, nous explorerons des fonctionnalités plus avancées pour créer des bots encore plus intelligents et adaptables.

Création d’un bot de clics avancé : Automatisation d’un jeu de clicker

Dans cette section, nous allons créer un bot plus sophistiqué pour automatiser un jeu de clicker. Ce type de jeu consiste généralement à cliquer pour gagner des ressources et à acheter des améliorations pour augmenter la production. Notre bot aura deux objectifs principaux :

1. Cliquer rapidement sur le cadeau principal pour générer des ressources.
2. Acheter automatiquement les améliorations disponibles, en commençant par les plus rentables.

Étape 1 : Mise en place du bot de clics

Commençons par créer un fichier clicker_bot.py :

import pyautogui
import time

# Coordonnées du cadeau principal
gift_pos = (x, y)  # Remplacez x et y par les coordonnées obtenues

# Délai avant le début de l'exécution
time.sleep(2)

# Boucle de clics
for i in range(20):
    pyautogui.click(gift_pos[0], gift_pos[1])

Pour obtenir les coordonnées du cadeau, utilisez le script get_position.py que nous avons créé précédemment.

Étape 2 : Détection des améliorations disponibles

Pour acheter les améliorations, nous devons détecter si elles sont disponibles en vérifiant leur couleur. Créons un nouveau script get_color.py pour nous aider :

import pyautogui
import time

time.sleep(2)
coords = pyautogui.position()
print(coords, '=', pyautogui.pixel(coords[0], coords[1]))

Utilisez ce script pour obtenir la couleur d’une amélioration disponible et stockez-la dans une variable :

purchasable_color = (r, g, b)  # Remplacez r, g, b par les valeurs obtenues

Étape 3 : Achat des améliorations

Maintenant, récupérons les positions des améliorations et implémentons la logique d’achat :

# Coordonnées des améliorations
upgrade_x = ...  # Coordonnée x commune à toutes les améliorations
upgrades_y = [y1, y2, y3, y4]  # Coordonnées y des 4 améliorations

# Fonction pour acheter les améliorations disponibles
def buy_upgrades():
    for y in upgrades_y[::-1]:  # Parcours en ordre inverse
        if pyautogui.pixel(upgrade_x, y) == purchasable_color:
            pyautogui.click(upgrade_x, y)

Étape 4 : Combinaison des fonctionnalités

Assemblons maintenant toutes ces fonctionnalités dans notre bot principal :

import pyautogui
import time

# Configuration
gift_pos = (x, y)
upgrade_x = ...
upgrades_y = [y1, y2, y3, y4]
purchasable_color = (r, g, b)

def click_gift(times):
    for _ in range(times):
        pyautogui.click(gift_pos[0], gift_pos[1])

def buy_upgrades():
    for y in upgrades_y[::-1]:
        if pyautogui.pixel(upgrade_x, y) == purchasable_color:
            pyautogui.click(upgrade_x, y)

# Délai avant le début de l'exécution
time.sleep(2)

# Boucle principale
while True:
    click_gift(20)
    buy_upgrades()

Étape 5 : Exécution et arrêt du bot

Pour exécuter le bot, lancez simplement le script avec python clicker_bot.py. Le bot commencera à cliquer et à acheter des améliorations automatiquement.

Pour arrêter le bot en toute sécurité, PyAutoGUI offre une fonction de sécurité intégrée : déplacez rapidement votre curseur dans l’un des quatre coins de l’écran. Cela forcera l’arrêt du programme, vous évitant ainsi des clics indésirables lorsque vous changez de fenêtre.

Conclusion et améliorations possibles

Ce bot de clicker démontre comment utiliser PyAutoGUI pour automatiser des tâches répétitives dans un jeu. Voici quelques idées pour améliorer davantage ce bot :

1. Ajouter des délais aléatoires entre les clics pour simuler un comportement plus humain.
2. Implémenter une détection d’images pour repérer des événements spéciaux ou des bonus dans le jeu.
3. Créer une interface utilisateur simple pour contrôler le bot (démarrage, arrêt, paramètres).
4. Ajouter des logs pour suivre les performances du bot au fil du temps.

Dans la prochaine section, nous explorerons comment créer un bot capable de détecter et d’interagir avec des images spécifiques à l’écran, ouvrant ainsi de nouvelles possibilités d’automatisation.

Création d’un bot de détection d’images : Le jeu de la taupe

Dans cette section, nous allons créer un bot plus avancé qui utilise la détection d’images pour jouer à un jeu de taupe. Contrairement à notre précédent bot, celui-ci devra localiser et cliquer sur une image (la taupe) qui peut apparaître n’importe où dans une zone définie de l’écran.

Étape 1 : Préparation de l’image

1. Capturez une image de la taupe dans le jeu.
2. Utilisez un outil comme removebg.com pour retirer l’arrière-plan de l’image.
3. Sauvegardez l’image PNG résultante dans un dossier “images” de votre projet.

Étape 2 : Création du script de base

Créez un fichier image_bot.py avec le contenu suivant :

import pyautogui
import time

# Délai avant le début de l'exécution
time.sleep(2)

Étape 3 : Définition de la zone de jeu

Utilisez le script get_position.py pour obtenir les coordonnées du coin supérieur gauche et du coin inférieur droit de la zone de jeu. Ajoutez ensuite ces informations à votre script :

# Définition de la région de jeu
game_region = (x1, y1, x2 - x1, y2 - y1)  # x1, y1 : coin supérieur gauche, x2, y2 : coin inférieur droit

Étape 4 : Implémentation de la détection d’image

Ajoutez le code suivant pour détecter et cliquer sur la taupe :

try:
    mole = pyautogui.locateCenterOnScreen(
        'images/taupe.png',
        region=game_region,
        grayscale=True,
        confidence=0.8
    )
    if mole:
        pyautogui.click(mole.x, mole.y)
except pyautogui.ImageNotFoundException:
    print('Image non trouvée')

Étape 5 : Création de la boucle principale

Encapsulez le code de détection dans une boucle infinie :

while True:
    try:
        mole = pyautogui.locateCenterOnScreen(
            'images/taupe.png',
            region=game_region,
            grayscale=True,
            confidence=0.8
        )
        if mole:
            pyautogui.click(mole.x, mole.y)
    except pyautogui.ImageNotFoundException:
        print('Image non trouvée')

    time.sleep(0.5)  # Petit délai pour ne pas surcharger le CPU

Code complet du bot de taupe

Voici le code complet de notre bot de taupe :

import pyautogui
import time

# Définition de la région de jeu
game_region = (x1, y1, x2 - x1, y2 - y1)  # Remplacez x1, y1, x2, y2 par les valeurs réelles

# Délai avant le début de l'exécution
time.sleep(2)

while True:
    try:
        mole = pyautogui.locateCenterOnScreen(
            'images/taupe.png',
            region=game_region,
            grayscale=True,
            confidence=0.8
        )
        if mole:
            pyautogui.click(mole.x, mole.y)
    except pyautogui.ImageNotFoundException:
        print('Image non trouvée')

    time.sleep(0.5)

Explication des paramètres clés :

• grayscale=True : Convertit l’image en niveaux de gris pour faciliter la détection.
• confidence=0.8 : Définit le niveau de confiance pour la correspondance d’image (0.8 = 80% de confiance).

Note importante : Pour utiliser le paramètre confidence, vous devez installer OpenCV :

pip install opencv-python

Exécution et arrêt du bot

Lancez le bot avec la commande python image_bot.py. Pour l’arrêter en toute sécurité, utilisez la même technique que précédemment : déplacez rapidement votre curseur dans l’un des coins de l’écran.

Conclusion et améliorations possibles

Ce bot de détection d’images démontre comment utiliser PyAutoGUI pour interagir avec des éléments visuels à l’écran. Voici quelques idées pour améliorer davantage ce bot :

1. Ajoutez plusieurs images de taupes pour gérer différentes apparences ou animations.
2. Implémentez une logique pour gérer les bonus ou les obstacles dans le jeu.
3. Créez un système de scoring pour suivre les performances du bot.
4. Optimisez la fréquence de détection pour équilibrer la réactivité et l’utilisation du CPU.

Dans la prochaine section, nous explorerons comment créer un bot encore plus avancé, capable de lire et d’interpréter du texte à l’écran pour prendre des décisions plus complexes.

Création d’un bot de lecture de texte : Le jeu d’arrosage des plantes

Dans cette section finale, nous allons créer un bot avancé capable de lire du texte à l’écran et de prendre des décisions basées sur cette information. Notre exemple sera un jeu d’arrosage de plantes où le but est d’amener toutes les plantes à un niveau de satisfaction de 20/20.

Étape 1 : Capture d’écran et reconnaissance de texte

Commençons par créer un fichier text_bot.py :

import pyautogui
import pytesseract
import time

# Délai avant le début de l'exécution
time.sleep(2)

# Définition de la région de capture
region = (x1, y1, x2 - x1, y2 - y1)  # Remplacez x1, y1, x2, y2 par les valeurs réelles

# Capture d'écran
screenshot = pyautogui.screenshot(region=region)
screenshot.save("capture.png")

# Reconnaissance de texte
text = pytesseract.image_to_string(screenshot)

Note : Assurez-vous d’avoir installé Tesseract OCR sur votre système et le module pytesseract (pip install pytesseract).

Étape 2 : Traitement du texte

Ajoutez le code suivant pour traiter le texte reconnu :

# Nettoyage et traitement du texte
lines = text.strip().replace('/20', '').split('\n')

Étape 3 : Logique d’arrosage

Implémentons la logique pour arroser les plantes :

# Positions des boutons d'arrosage
x = ...  # Position x commune à tous les boutons
y_start = ...  # Position y du premier bouton
y_step = ...  # Distance verticale entre deux boutons

while True:
    is_over = True
    for i, line in enumerate(lines):
        water_times = 20 - int(line)
        if water_times > 0:
            is_over = False
            for _ in range(water_times):
                pyautogui.click(x, y_start + y_step * i)
                time.sleep(0.1)  # Petit délai entre chaque clic

    if is_over:
        print("Toutes les plantes sont satisfaites !")
        break

    # Mise à jour des niveaux de soif
    screenshot = pyautogui.screenshot(region=region)
    text = pytesseract.image_to_string(screenshot)
    lines = text.strip().replace('/20', '').split('\n')

Code complet du bot de lecture de texte

Voici le code complet de notre bot d’arrosage de plantes :

import pyautogui
import pytesseract
import time

# Définition de la région de capture
region = (x1, y1, x2 - x1, y2 - y1)  # Remplacez x1, y1, x2, y2 par les valeurs réelles

# Positions des boutons d'arrosage
x = ...  # Position x commune à tous les boutons
y_start = ...  # Position y du premier bouton
y_step = ...  # Distance verticale entre deux boutons

# Délai avant le début de l'exécution
time.sleep(2)

while True:
    # Capture d'écran et reconnaissance de texte
    screenshot = pyautogui.screenshot(region=region)
    text = pytesseract.image_to_string(screenshot)
    lines = text.strip().replace('/20', '').split('\n')

    is_over = True
    for i, line in enumerate(lines):
        water_times = 20 - int(line)
        if water_times > 0:
            is_over = False
            for _ in range(water_times):
                pyautogui.click(x, y_start + y_step * i)
                time.sleep(0.1)  # Petit délai entre chaque clic

    if is_over:
        print("Toutes les plantes sont satisfaites !")
        break

    time.sleep(1)  # Délai avant la prochaine vérification

Exécution et arrêt du bot

Lancez le bot avec la commande python text_bot.py. Le bot s’arrêtera automatiquement une fois que toutes les plantes auront atteint un niveau de satisfaction de 20/20.

Aller plus loin avec le développement de bots en Python

Ce tutoriel vous a montré comment créer trois types de bots différents en utilisant PyAutoGUI :

1. Un bot de clics basé sur la couleur des pixels
2. Un bot de détection d’images
3. Un bot de lecture et d’interprétation de texte

Ces techniques peuvent être combinées et étendues pour créer des bots plus complexes et puissants. Voici quelques idées pour aller plus loin :

1. Ajoutez une interface utilisateur pour contrôler vos bots
2. Implémentez des mécanismes de sécurité pour éviter les actions non désirées
3. Utilisez l’apprentissage automatique pour améliorer la prise de décision des bots
4. Créez des bots capables de jouer à des jeux plus complexes ou d’automatiser des tâches professionnelles

N’oubliez pas que l’utilisation de bots doit toujours être éthique et conforme aux conditions d’utilisation des applications ou des jeux que vous automatisez.

Avantages et inconvénients des bots basés sur PyAutoGUI

L’avantage majeur de ce type de bots est leur discrétion. Contrairement aux méthodes qui modifient directement le client d’un jeu ou d’une application, ces bots sont beaucoup moins détectables. De plus, ils sont particulièrement utiles dans les situations où l’on n’a pas accès au code source ou aux fichiers du client, ce qui est souvent le cas pour les applications en ligne ou les jeux protégés.

Cependant, il est important de noter un inconvénient significatif : ces bots occupent la souris et le clavier de votre ordinateur pendant leur exécution, ce qui peut limiter votre capacité à utiliser votre machine pour d’autres tâches simultanément. Une solution à ce problème est d’exécuter le bot dans une machine virtuelle (VM), ce qui vous permet de continuer à utiliser votre ordinateur normalement tout en laissant le bot fonctionner dans un environnement isolé.

Maintenant que vous avez les bases, les possibilités sont infinies ! Quelle sera votre prochaine création ?