Comment créer un script de jeu en python

Cet article utilisera le mini-jeu 4399 "Pet Lianliankan Classic Edition 2" comme cas de test. En identifiant de petites icônes et en simulant des clics de souris, l'appariement peut être rapidement complété pour compléter le script du jeu.

Le navigateur ouvre la fenêtre du jeu (fenêtre unique). La capture d'écran de l'interface principale du jeu nécessite deux coordonnées (coordonnées du coin supérieur gauche et coordonnées du coin inférieur droit) pour déterminer l'origine. dans le coin supérieur gauche de l'écran et les coordonnées sont incertaines. Les étudiants qui cliquent sur la valeur peuvent prendre une capture d'écran en plein écran et utiliser un logiciel de retouche d'image pour afficher les valeurs des coordonnées. (Apprentissage recommandé : Tutoriel vidéo Python)

Récupérez le handle de la fenêtre, voici le titre de la barre de titre du navigateur (clic droit - afficher le code source - titre, plus le nom du logiciel) Pour exemple : " Pet Lianliankan Classic 2, Pet Lianliankan Classic Edition 2 mini-jeux, 4399 mini-jeux www.4399.com - Google Chrome". Obtenez la poignée de fenêtre et vous êtes prêt à partir.

Idée globale de développement : interceptez l'image principale du jeu ---> divisée en petites images ---> comparez chaque petite image, comparez la familiarité de l'image et stockez le numéro dans la matrice-- -> matrice de paires Effectuer des calculs connectables --->

Récupérez le handle de la fenêtre et placez la fenêtre en haut

Python peut utiliser le module win32gui pour appeler l'API Windows pour faire fonctionner la fenêtre et utiliser FindWindow() méthode pour obtenir le handle de la fenêtre (handle), vous devez transmettre deux paramètres. Le premier est le handle de la fenêtre parent (remplissez simplement 0 ici) et le deuxième paramètre est le nom de la fenêtre (titre de l'étiquette - Google Chrome). ). Après avoir récupéré le handle, placez la fenêtre devant via SetForegroundWindows(). Ici, vous pouvez passer le rapport de la fenêtre de jeu. Le code est le suivant :

import win32gui

class GameAssist:

    def __init__(self, wdname):
        """初始化"""

        # 取得窗口句柄
        self.hwnd = win32gui.FindWindow(0, wdname)
        if not self.hwnd:
            print("窗口找不到，请确认窗口句柄名称：【%s】" % wdname )
            exit()
        # 窗口显示最前面
        win32gui.SetForegroundWindow(self.hwnd)


if __name__ == "__main__":
    # wdname 为连连看窗口的名称，必须写完整
    wdname = u'宠物连连看经典版2,宠物连连看经典版2小游戏,4399小游戏 www.4399.com - Google Chrome'

    demo = GameAssist(wdname)
    demo.start()

Intercepter l'interface du jeu, diviser le. et comparez les images

La vérification du programme prend un certain temps. Si l'image capturée n'est pas bonne, cela affectera les opérations ultérieures, le plus important est donc de confirmer la. les valeurs de coordonnées du coin supérieur gauche et du coin inférieur droit du jeu, ainsi que chacune La largeur et la hauteur de la petite icône. Comme le montre la figure ci-dessous, interceptez d'abord l'intégralité du diagramme de l'interface du jeu, puis divisez les petites icônes, puis comparez chaque icône, puis remplacez l'icône par un nombre et stockez-la dans la matrice (la matrice numérique ici n'est pas cohérente avec le jeu). schéma, le principe est le même).

Utilisez la méthode ImageGrab.grab() pour prendre une capture d'écran basée sur les deux coordonnées du coin supérieur gauche et du coin inférieur droit définies par l'initialisation, puis transmettez simplement un tuple, puis divisez et. coupez la grande image. Enregistrez-les en petites icônes une par une dans le tableau images_list.

def screenshot(self):
        """屏幕截图"""

        # 1、用grab函数截图，参数为左上角和右下角左标
        # image = ImageGrab.grab((417, 257, 885, 569))
        image = ImageGrab.grab(self.scree_left_and_right_point)

        # 2、分切小图
        # exit()
        image_list = {}
        offset = self.im_width  # 39

        # 8行12列
        for x in range(8):
            image_list[x] = {}
            for y in range(12):
                # print("show",x, y)
                # exit()
                top = x * offset
                left = y * offset
                right = (y + 1) * offset
                bottom = (x + 1) * offset

                # 用crop函数切割成小图标，参数为图标的左上角和右下角左边
                im = image.crop((left, top, right, bottom))
                # 将切割好的图标存入对应的位置
                image_list[x][y] = im

        return image_list

La petite icône coupée par le code ci-dessus est convertie en matrice numérique. Si l'icône a été stockée dans image_type_list, l'index sera renvoyé s'il n'existe pas, il sera ajouté, et le. la longueur actuelle sera le numéro de l'icône nouvellement ajoutée. , le code est le suivant :

def image2num(self, image_list):
        """将图标矩阵转换成数字矩阵"""

        # 1、创建全零矩阵和空的一维数组
        arr = np.zeros((10, 14), dtype=np.int32)    # 以数字代替图片
        image_type_list = []

        # 2、识别出不同的图片，将图片矩阵转换成数字矩阵
        for i in range(len(image_list)):
            for j in range(len(image_list[0])):
                im = image_list[i][j]
                
                # 验证当前图标是否已存入
                index = self.getIndex(im, image_type_list)

                # 不存在image_type_list
                if index <p>Le getIndex ci-dessus sert à comparer les images pour déterminer si l'icône est apparue (si elle existe déjà dans la liste image_type_list, si elle n'apparaît pas, elle sera ajoutée). Ici, la distance de Hamming est utilisée pour déterminer la connaissance des deux images, régler le seuil à 10. Lorsqu'elle est inférieure au seuil, elle est considérée comme le degré. même image. Le code spécifique est le suivant : </p><pre class="brush:php;toolbar:false"># 检查数组中是否有图标,如果有则返回索引下表
    def getIndex(self,im, im_list):
        for i in range(len(im_list)):
            if self.isMatch(im, im_list[i]):
                return i

        return -1

    # 汉明距离判断两个图标是否一样
    def isMatch(self, im1, im2):

        # 缩小图标，转成灰度
        image1 = im1.resize((20, 20), Image.ANTIALIAS).convert("L")
        image2 = im2.resize((20, 20), Image.ANTIALIAS).convert("L")

        # 将灰度图标转成01串,即系二进制数据
        pixels1 = list(image1.getdata())
        pixels2 = list(image2.getdata())

        avg1 = sum(pixels1) / len(pixels1)
        avg2 = sum(pixels2) / len(pixels2)
        hash1 = "".join(map(lambda p: "1" if p > avg1 else "0", pixels1))
        hash2 = "".join(map(lambda p: "1" if p > avg2 else "0", pixels2))

        # 统计两个01串不同数字的个数
        match = sum(map(operator.ne, hash1, hash2))

        # 阀值设为10
        return match <p>Algorithme de connexion noyau-icône du programme (recherche de chemin)</p><p>Voici uniquement le code de l'algorithme Effectuez une analyse simple. comprenez bien le programme, vous pouvez laisser un message et faire un suivi avec une analyse graphique et textuelle. </p><p>Grâce au processus de développement ci-dessus, vous pouvez essentiellement obtenir une matrice comme celle-ci. Comparez simplement deux valeurs avec le même nombre pour trouver des chemins connectables, s'ils sont trouvés, simulez une opération de clic. Voici une brève introduction aux règles du jeu : 8 lignes sur 12 colonnes de zone d'icône de jeu. Le 0 en périphérie indique en fait qu'il peut être passé lors de la recherche d'un chemin. Par exemple, les coordonnées (1, 1) peuvent être. connecté avec (1,10), (7, 1) Connectez-vous avec (7,2). L'idée de la méthode </p><pre class="brush:php;toolbar:false">arr = [
    [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
    [ 0,  1,  2,  3,  4,  5,  4,  6,  7,  2,  1,  1,  8,  0],
    [ 0,  9,  3,  3, 10,  4,  7, 11,  7,  2,  3,  1,  6,  0],
    [ 0,  6,  7,  4, 11,  5,  8,  1,  6,  5,  4,  2,  8,  0],
    [ 0,  6,  2,  9,  6,  8,  9,  7, 12, 11,  3, 11, 11,  0],
    [ 0,  5,  9,  8,  9,  2,  6, 11, 11,  3,  9,  2, 12,  0],
    [ 0, 12,  5, 12,  5, 10,  5,  6,  5,  7, 12,  4,  3,  0],
    [ 0,  1,  8, 10, 12,  9, 10,  4,  3,  7,  2,  1, 10,  0],
    [ 0,  1,  4, 10,  8, 12, 10, 10,  9, 12,  8,  7, 11,  0],
    [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
]

 : Pour trouver un chemin, trouvez d'abord un ensemble de coordonnées qui peuvent être directement connectées horizontalement et verticalement. Par exemple, un ensemble tel que la coordonnée p1 (1,1) a. [ (0,1), ( 1,0)], et l'ensemble connectable d'une autre coordonnée p2 (1,10) est [(0,10)], puis comparez les ensembles de coordonnées connectables de p1 et p2 si le. les coordonnées de l'ensemble sont également connectables, cela signifie que p1 et p2 peuvent être connectés. Évidemment, (0,1) et (0,10) sont sur la même ligne et peuvent être connectés. p1 et p2. Le code est le suivant :

Une brève analyse du processus d'implémentation du code : transmettez deux valeurs de coordonnées qui doivent être comparées dans isReachable(), puis obtenez les ensembles de coordonnées qui peuvent être connecté aux deux points dans les directions horizontale et verticale (isRowConnect(), isColConnect()), et enfin Parcourez la collection et comparez s'il en existe une pouvant être liée. Si elle existe, cela signifie que les deux coordonnées entrantes peuvent être connectées.

# 是否为同行或同列且可连
    def isReachable(self, x1, y1, x2, y2):
        # 1、先判断值是否相同
        if self.im2num_arr[x1][y1] != self.im2num_arr[x2][y2]:
            return False

        # 1、分别获取两个坐标同行或同列可连的坐标数组
        list1 = self.getDirectConnectList(x1, y1)
        list2 = self.getDirectConnectList(x2, y2)
        # print(x1, y1, list1)
        # print(x2, y2, list2)

        # exit()

        # 2、比较坐标数组中是否可连
        for x1, y1 in list1:
            for x2, y2 in list2:
                if self.isDirectConnect(x1, y1, x2, y2):
                    return True
        return False

    # 获取同行或同列可连的坐标数组
    def getDirectConnectList(self, x, y):

        plist = []
        for px in range(0, 10):
            for py in range(0, 14):
                # 获取同行或同列且为0的坐标
                if self.im2num_arr[px][py] == 0 and self.isDirectConnect(x, y, px, py):
                    plist.append([px, py])

        return plist

    # 是否为同行或同列且可连
    def isDirectConnect(self, x1, y1, x2, y2):
        # 1、位置完全相同
        if x1 == x2 and y1 == y2:
            return False

        # 2、行列都不同的
        if x1 != x2 and y1 != y2:
            return False

        # 3、同行
        if x1 == x2 and self.isRowConnect(x1, y1, y2):
            return True

        # 4、同列
        if y1 == y2 and self.isColConnect(y1, x1, x2):
            return True

        return False

    # 判断同行是否可连
    def isRowConnect(self, x, y1, y2):
        minY = min(y1, y2)
        maxY = max(y1, y2)

        # 相邻直接可连
        if maxY - minY == 1:
            return True

        # 判断两个坐标之间是否全为0
        for y0 in range(minY + 1, maxY):
            if self.im2num_arr[x][y0] != 0:
                return False
        return True

    # 判断同列是否可连
    def isColConnect(self, y, x1, x2):
        minX = min(x1, x2)
        maxX = max(x1, x2)

        # 相邻直接可连
        if maxX - minX == 1:
            return True

        # 判断两个坐标之间是否全为0
        for x0 in range(minX + 1, maxX):
            if self.im2num_arr[x0][y] != 0:
                return False
        return True

Apprendre un tel script auxiliaire de jeu est également très utile pour cultiver un intérêt personnel pour la programmation. Cela peut être considéré comme un bon passe-temps après le travail. J'étudierai et en apprendrai davantage dans ces directions à l'avenir.

Pour plus d'articles techniques liés à Python, veuillez visiter la colonne Tutoriel Python pour apprendre !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!