python怎样制造游戏剧本【Python教程】,python

本文将以4399小游戏《宠物连连看典范版2》作为测试案例，经由历程辨认小图标，模仿鼠标点击，疾速完成配对完成游戏剧本。

浏览器翻开游戏窗口（单个一个窗口），游戏重要界面截图须要两个坐标（左上角坐标和右下角坐标）来肯定，原点平常是屏幕左上角，不肯定坐标点值的同砚，能够全屏截图，用编辑图片软件检察坐标值。（引荐进修：Python视频教程）

猎取窗口句柄，这里就是浏览器标题栏的标题了（右键-检察源代码-title，加上软件名）比方：“宠物连连看典范2,宠物连连看典范版2小游戏,4399小游戏 www.4399.com - Google Chrome“。猎取窗口句柄就能够最先了。

总体开辟思绪：截取游戏主图 ---> 支解成小图 ---> 对照每一个小图，对照图片了解度，编号存入矩阵 ---> 对矩阵举行可连盘算 ---> 模仿点击。

猎取窗口句柄，把窗口置顶

python能够运用win32gui模块挪用Windows API完成对窗口的操纵，运用FindWindow()要领能够猎取窗口的句柄（handle），须要传入两个参数，第一个为父窗口句柄（这里填0即可），第二个参数是窗口的称号（标签title - Google Chrome）。猎取句柄以后然后经由历程SetForegroundWindows() 设置窗口在前面，这里传入游戏窗口的告发即可，代码以下：

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()

截取游戏界面，支解图标，图片比较

这里须要消费一些时刻来校验顺序，假如截取的图片不好，则会影响后续操纵，所以比较重要的是确认游戏左上角和右下角这两个坐标值，以及每一个小图标的宽高。以下图所示，先截取全部游戏界面图，然后支解小图标，接着对每一个图标举行比较，然后以编号替代图标存入矩阵（这里的编号矩阵和游戏图不一致，道理一样）。

依据初始化设定的左上角和右下角两个坐标，运用ImageGrab.grab()要领举行截图，传入一个元组即可，然后对这个大图举行支解，切割成一个个小图标存入到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

经由历程上面代码切割的小图标，转成数字矩阵，假如图标已存入image_type_list则返回这个索引，假如不存在，则在追加进去，然后当前长度就是这个新到场图标的编号，代码以下所示：

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 < 0:
                    image_type_list.append(im)
                    arr[i + 1][j + 1] = len(image_type_list)
                else:
                    arr[i + 1][j + 1] = index + 1

        print("图标数：", len(image_type_list))

        self.im2num_arr = arr
        return arr

上面的getIndex就是对照图片，推断图标是不是涌现过（是不是已存在image_type_list中，没涌现则追加进去），这里运用汉明间隔推断两个图片的了解度，设置阀值10，当小于阀值则认为是统一个图片，细致代码以下：　　

# 搜检数组中是不是有图标,假如有则返回索引下表
    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 < 10

顺序中心-图标衔接算法（途径寻觅）

这里仅对算法代码举行简朴剖析，假如对顺序不好明白，能够留言，后续能够图文剖析。

经由历程上面的开辟流程，基础猎取以下如许的矩阵，只需比较两个编号雷同的值举行可连途径寻觅，假如找到即举行模仿点击操纵。这里简朴引见下游戏规则：8行乘12列游戏图标地区，外围的0实在示意寻觅途径的时刻能够经由历程，比方坐标（1, 1）能够与（1,10）举行衔接、（7, 1）和（7,2）举行衔接。

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]
]

法的思绪：途径的寻觅首先是寻觅一个坐标的横向竖向能够直接相连的坐标鸠合，比方坐标p1（1,1）如许的鸠合有[ （0,1）, （1,0） ]，别的一个坐标p2（1,10）的可连鸠合为[ （0,10） ]，然后再对p1和p2的可连坐标鸠合举行比较，假如鸠合中坐标也有可连，则示意p1和p2可连，很明显，（0,1）和（0,10）为统一行且可连，如许就示意p1和p2两点存在可连途径了，代码以下所示：

简朴剖析下代码完成历程：在isReachable()传入两个须要比较的坐标值，然后离别猎取两个点横竖向（isRowConnect()、isColConnect()）能够衔接的坐标鸠合，末了再对鸠合举行遍历比较是不是存在可连的，假如存在则示意传入的两个坐标是能够衔接的。

# 是不是为偕行或同列且可连
    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

进修如许一个游戏辅佐剧本，关于个人造就编程兴致也是有许多协助的，在事情之余不失为一个好的消遣体式格局，以后会多向这些方向研究进修。

更多Python相干技术文章，请接见Python教程栏目举行进修！

以上就是python怎样制造游戏剧本的细致内容，更多请关注ki4网别的相干文章！