Python para escribir el juego gomoku (con código fuente completo)

Others 2021-03-28 22:08:49 views: null

comienzo

comienzo

Dibujar un tablero de ajedrez

Primero que nada, debemos  dibujar un tablero de ajedrez, no es difícil dibujar un tablero de 19 × 19 o 15 × 15 con  pygame, esto se ha usado muchas veces en el artículo anterior, así que no lo repetiré.

Dibujar piezas de ajedrez

Lo que hay que decir es dibujar piezas de ajedrez, porque no hay una imagen de pieza de ajedrez adecuada, así que dibuje las piezas de ajedrez usted mismo.  El círculo
que  pygame.draw.circledibujamos es así:

Muchas personas aprenden Python y después de dominar la gramática básica, no saben dónde encontrar casos para comenzar.

Muchas personas que han realizado estudios de casos no saben cómo adquirir conocimientos más avanzados.

Entonces, para estos tres tipos de personas, les proporcionaré una buena plataforma de aprendizaje, ¡gratis para recibir tutoriales en video, libros electrónicos y el código fuente del curso!

Grupo QQ: 701698587


La forma irregular es muy obvia y hay  una función para dibujar una pygame.draw línea recta suavizada  aaline, pero no existe  aacircletal función para dibujar un círculo suavizado.

Necesitas usarlo aquí  pygame.gfxdraw . pygame.gfxdraw Actualmente es solo una versión experimental, lo que significa que esta  API  puede  cambiar o desaparecer en futuras versiones de  pygame .

Para dibujar formas rellenas y de suavizado, primero use la versión aa * de la función y luego use la versión completa. P.ej:

imagen

col = (255, 0, 0)
surf.fill((255, 255, 255))
pygame.gfxdraw.aacircle(surf, x, y, 30, col)
pygame.gfxdraw.filled_circle(surf, x, y, 30, col)

 

Probemos este método dibujando una pieza en el tablero de ajedrez.

Puede ver que el efecto se ha mejorado significativamente.

Laozi

El movimiento necesita determinar el evento del mouse.Cuando se hace clic con el botón izquierdo del mouse, se obtiene la posición del clic del mouse, y luego, de acuerdo con la posición del tablero de ajedrez, se calcula la posición del jugador de ajedrez en el tablero de ajedrez.

    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                sys.exit()
            elif event.type == MOUSEBUTTONDOWN:
                pressed_array = pygame.mouse.get_pressed()
                if pressed_array[0]:  # 鼠标左键点击
                    mouse_pos = pygame.mouse.get_pos()
                    click_point = _get_clickpoint(mouse_pos)

 

Decisión de victoria

Cuando un niño cae, ¿cómo determinar si ganar o no?

Lo cierto es que cuando cierto niño cae, si hay una quinta conexión, entonces el niño caído debe estar en esta quinta conexión. Entonces este problema se puede simplificar: no necesitamos escanear toda la placa, solo necesitamos escanearla horizontal y verticalmente para determinar si hay 5 conexiones.

Definimos una clase de tablero de ajedrez, en la que se instancia una matriz bidimensional de 19 × 19. Los valores iniciales son todos 0, lo que significa vacío, y 1 significa negro y 2 significa blanco. Esta clase proporciona un método de ubicación externamente  drop, que recibe los parámetros del cuadro de ubicación y las coordenadas de ubicación. Si la ubicación es exitosa, devuelve el ganador, de lo contrario, devuelve Ninguno.

Chessman = namedtuple('Chessman', 'Name Value Color')
Point = namedtuple('Point', 'X Y')

BLACK_CHESSMAN = Chessman('黑子', 1, (45, 45, 45))
WHITE_CHESSMAN = Chessman('白子', 2, (219, 219, 219))

offset = [(1, 0), (0, 1), (1, 1), (1, -1)]


class Checkerboard:
    def __init__(self, line_points):
        self._line_points = line_points
        self._checkerboard = [[0] * line_points for _ in range(line_points)]

    def _get_checkerboard(self):
        return self._checkerboard

    checkerboard = property(_get_checkerboard)

    # 判断是否可落子
    def can_drop(self, point):
        return self._checkerboard[point.Y][point.X] == 0

    def drop(self, chessman, point):
        """
        落子
        :param chessman: 黑子/白子
        :param point:落子位置
        :return:若该子落下之后即可获胜，则返回获胜方，否则返回 None
        """
        print(f'{chessman.Name} ({point.X}, {point.Y})')
        self._checkerboard[point.Y][point.X] = chessman.Value

        if self._win(point):
            print(f'{chessman.Name}获胜')
            return chessman

    # 判断是否赢了
    def _win(self, point):
        cur_value = self._checkerboard[point.Y][point.X]
        for os in offset:
            if self._get_count_on_direction(point, cur_value, os[0], os[1]):
                return True

    def _get_count_on_direction(self, point, value, x_offset, y_offset):
        count = 1
        for step in range(1, 5):
            x = point.X + step * x_offset
            y = point.Y + step * y_offset
            if 0 <= x < self._line_points and 0 <= y < self._line_points and self._checkerboard[y][x] == value:
                count += 1
            else:
                break
        for step in range(1, 5):
            x = point.X - step * x_offset
            y = point.Y - step * y_offset
            if 0 <= x < self._line_points and 0 <= y < self._line_points and self._checkerboard[y][x] == value:
                count += 1
            else:
                break

        return count >= 5

 

Aquí he definido un offset. Tenemos que calcular un total de 4 líneas horizontal y verticalmente. Si alguna línea aparece 5 veces consecutivas, se considerará una ganancia. El método de cálculo es en realidad el mismo, pero la dirección es diferente, así que defina una matriz de compensación, diferentes compensaciones representan diferentes direcciones, de modo que pueda usar el bucle para lograr, guardar una gran cantidad de código.

Colocación de la computadora

Este es el punto culminante de todo el artículo, cómo enseñarle a la computadora a jugar Gobang.
En primer lugar, estoy utilizando un método relativamente tradicional, no un aprendizaje profundo.

Gobang es lograr 5 conexiones, así que al principio mi idea era guardar todas las conexiones en un arreglo y elegir la conexión más larga al colocar una pieza. Pero hay un problema que no se puede resolver ¿Cómo hacer que la computadora reconozca el "tres-tres"?

Luego vi un artículo en Internet. El método utilizado es: recorrer las posiciones vacías en el tablero de ajedrez y calcular si hay un jugador en cada posición en 8 direcciones. Si hay uno, sume 10 puntos, y finalmente elija la posición con la puntuación más alta.

Esto no es muy riguroso. El nivel estimado por computadora escrito es muy bueno, pero la idea es correcta. La ubicación es buscar el lugar que más valga, luego simplemente hacemos una valoración de cada lugar que se puede ubicar y seleccionamos la mejor solución. .

Aquí tenemos que entender varios patrones básicos de ajedrez de Gobang: cinco consecutivos, cuatro en vivo, cuatro golpes, tres en vivo, tres en vivo, dos en vivo, dos en vivo.

Cinco consecutivos

Como sugiere el nombre, cinco piezas del mismo color se conectan entre sí y ganan

imagen

Vivir cuatro

Cuatro piezas del mismo color están conectadas entre sí, y no hay ninguna pieza opuesta que bloquee en ninguno de los lados, hay dos piezas con cinco puntos.

Okushi

Cuatro piezas del mismo color están conectadas entre sí, y un lado está bloqueado por la pieza del oponente, o las cuatro piezas no están conectadas y hay un espacio.En este momento, solo hay una con cinco puntos.

Vive tres, salta en vivo tres

Vive dos y duerme dos

Vivir dos puede formar dos de vivir tres; dormir dos puede formar dos de dormir tres. La imagen no se muestra aquí, consulte Living Three Sleeping Three.

Mecanismo de puntuación

Después de comprender estos patrones de ajedrez, de acuerdo con nuestro pensamiento anterior, es cómo anotar.

  • En primer lugar, definitivamente no hay cinco consecutivos. Las cinco victorias y pérdidas consecutivas ya se han dividido, por lo que mientras el juego esté en curso, no habrá cinco consecutivos. Entonces, ¿cuál es la máxima prioridad? Naturalmente, son cuatro vivos.

  • El segundo es el "cuatro" del oponente. Si el oponente vive cuatro, pierdes lo mismo si defiendes o fallas. Si el oponente acelera cuatro, debes defender.

  • Una vez más, son nuestros tres o cuatro en vivo, tres y cuatro en vivo están en el mismo nivel y el oponente debe defender.

  • Una vez más, son tres o cuatro en vivo del oponente.

Y así. Podemos resumir una pequeña regla:

  • Con la misma forma de ajedrez, nuestro lado es mejor que el otro lado.

  • Corre cuatro y vive en tres niveles, duerme tres y vive en dos niveles.

  • Si hay un espacio en el medio, debe ser un poco más bajo que el que no tiene espacios, pero no se degradará.

La lógica básica es así. No escribí muy bien este fragmento de código. Escribí más de 100 líneas del juicio completo, así que no publicaré el código. Puede descargar el código fuente para verlo.

Gobang negro es imprescindible. En el código, el jugador es el negro primero y la computadora el blanco en segundo lugar. Por lo tanto, un buen juego puede ganar completamente a la computadora, pero también es probable que un pequeño error sea anulado por la computadora.

 

Todo el código fuente:

ManAndMachine.py

"" "Gobang: Batalla hombre-máquina" ""

import sysimport randomimport pygamefrom pygame.locals import *import pygame.gfxdrawfrom checkerboard import Checkerboard, BLACK_CHESSMAN, WHITE_CHESSMAN, offset, Point
SIZE = 30  # 棋盘每个点时间的间隔Line_Points = 19  # 棋盘每行/每列点数Outer_Width = 20  # 棋盘外宽度Border_Width = 4  # 边框宽度Inside_Width = 4  # 边框跟实际的棋盘之间的间隔Border_Length = SIZE * (Line_Points - 1) + Inside_Width * 2 + Border_Width  # 边框线的长度Start_X = Start_Y = Outer_Width + int(Border_Width / 2) + Inside_Width  # 网格线起点（左上角）坐标SCREEN_HEIGHT = SIZE * (Line_Points - 1) + Outer_Width * 2 + Border_Width + Inside_Width * 2  # 游戏屏幕的高SCREEN_WIDTH = SCREEN_HEIGHT + 200  # 游戏屏幕的宽
Stone_Radius = SIZE // 2 - 3  # 棋子半径Stone_Radius2 = SIZE // 2 + 3Checkerboard_Color = (0xE3, 0x92, 0x65)  # 棋盘颜色BLACK_COLOR = (0, 0, 0)WHITE_COLOR = (255, 255, 255)RED_COLOR = (200, 30, 30)BLUE_COLOR = (30, 30, 200)
RIGHT_INFO_POS_X = SCREEN_HEIGHT + Stone_Radius2 * 2 + 10

def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):    imgText = font.render(text, True, fcolor)    screen.blit(imgText, (x, y))

def main():    pygame.init()    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))    pygame.display.set_caption('五子棋')
    font1 = pygame.font.SysFont('SimHei', 32)    font2 = pygame.font.SysFont('SimHei', 72)    fwidth, fheight = font2.size('黑方获胜')
    checkerboard = Checkerboard(Line_Points)    cur_runner = BLACK_CHESSMAN    winner = None    computer = AI(Line_Points, WHITE_CHESSMAN)
    black_win_count = 0    white_win_count = 0
    while True:        for event in pygame.event.get():            if event.type == QUIT:                sys.exit()            elif event.type == KEYDOWN:                if event.key == K_RETURN:                    if winner is not None:                        winner = None                        cur_runner = BLACK_CHESSMAN                        checkerboard = Checkerboard(Line_Points)                        computer = AI(Line_Points, WHITE_CHESSMAN)            elif event.type == MOUSEBUTTONDOWN:                if winner is None:                    pressed_array = pygame.mouse.get_pressed()                    if pressed_array[0]:                        mouse_pos = pygame.mouse.get_pos()                        click_point = _get_clickpoint(mouse_pos)                        if click_point is not None:                            if checkerboard.can_drop(click_point):                                winner = checkerboard.drop(cur_runner, click_point)                                if winner is None:                                    cur_runner = _get_next(cur_runner)                                    computer.get_opponent_drop(click_point)                                    AI_point = computer.AI_drop()                                    winner = checkerboard.drop(cur_runner, AI_point)                                    if winner is not None:                                        white_win_count += 1                                    cur_runner = _get_next(cur_runner)                                else:                                    black_win_count += 1                        else:                            print('超出棋盘区域')
        # 画棋盘        _draw_checkerboard(screen)
        # 画棋盘上已有的棋子        for i, row in enumerate(checkerboard.checkerboard):            for j, cell in enumerate(row):                if cell == BLACK_CHESSMAN.Value:                    _draw_chessman(screen, Point(j, i), BLACK_CHESSMAN.Color)                elif cell == WHITE_CHESSMAN.Value:                    _draw_chessman(screen, Point(j, i), WHITE_CHESSMAN.Color)
        _draw_left_info(screen, font1, cur_runner, black_win_count, white_win_count)
        if winner:            print_text(screen, font2, (SCREEN_WIDTH - fwidth)//2, (SCREEN_HEIGHT - fheight)//2, winner.Name + '获胜', RED_COLOR)
        pygame.display.flip()

def _get_next(cur_runner):    if cur_runner == BLACK_CHESSMAN:        return WHITE_CHESSMAN    else:        return BLACK_CHESSMAN

# 画棋盘def _draw_checkerboard(screen):    # 填充棋盘背景色    screen.fill(Checkerboard_Color)    # 画棋盘网格线外的边框    pygame.draw.rect(screen, BLACK_COLOR, (Outer_Width, Outer_Width, Border_Length, Border_Length), Border_Width)    # 画网格线    for i in range(Line_Points):        pygame.draw.line(screen, BLACK_COLOR,                         (Start_Y, Start_Y + SIZE * i),                         (Start_Y + SIZE * (Line_Points - 1), Start_Y + SIZE * i),                         1)    for j in range(Line_Points):        pygame.draw.line(screen, BLACK_COLOR,                         (Start_X + SIZE * j, Start_X),                         (Start_X + SIZE * j, Start_X + SIZE * (Line_Points - 1)),                         1)    # 画星位和天元    for i in (3, 9, 15):        for j in (3, 9, 15):            if i == j == 9:                radius = 5            else:                radius = 3            # pygame.draw.circle(screen, BLACK, (Start_X + SIZE * i, Start_Y + SIZE * j), radius)            pygame.gfxdraw.aacircle(screen, Start_X + SIZE * i, Start_Y + SIZE * j, radius, BLACK_COLOR)            pygame.gfxdraw.filled_circle(screen, Start_X + SIZE * i, Start_Y + SIZE * j, radius, BLACK_COLOR)

# 画棋子def _draw_chessman(screen, point, stone_color):    # pygame.draw.circle(screen, stone_color, (Start_X + SIZE * point.X, Start_Y + SIZE * point.Y), Stone_Radius)    pygame.gfxdraw.aacircle(screen, Start_X + SIZE * point.X, Start_Y + SIZE * point.Y, Stone_Radius, stone_color)    pygame.gfxdraw.filled_circle(screen, Start_X + SIZE * point.X, Start_Y + SIZE * point.Y, Stone_Radius, stone_color)

# 画左侧信息显示def _draw_left_info(screen, font, cur_runner, black_win_count, white_win_count):    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, Start_X + Stone_Radius2), BLACK_CHESSMAN.Color)    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, Start_X + Stone_Radius2 * 4), WHITE_CHESSMAN.Color)
    print_text(screen, font, RIGHT_INFO_POS_X, Start_X + 3, '玩家', BLUE_COLOR)    print_text(screen, font, RIGHT_INFO_POS_X, Start_X + Stone_Radius2 * 3 + 3, '电脑', BLUE_COLOR)
    print_text(screen, font, SCREEN_HEIGHT, SCREEN_HEIGHT - Stone_Radius2 * 8, '战况：', BLUE_COLOR)    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, SCREEN_HEIGHT - int(Stone_Radius2 * 4.5)), BLACK_CHESSMAN.Color)    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, SCREEN_HEIGHT - Stone_Radius2 * 2), WHITE_CHESSMAN.Color)    print_text(screen, font, RIGHT_INFO_POS_X, SCREEN_HEIGHT - int(Stone_Radius2 * 5.5) + 3, f'{black_win_count} 胜', BLUE_COLOR)    print_text(screen, font, RIGHT_INFO_POS_X, SCREEN_HEIGHT - Stone_Radius2 * 3 + 3, f'{white_win_count} 胜', BLUE_COLOR)

def _draw_chessman_pos(screen, pos, stone_color):    pygame.gfxdraw.aacircle(screen, pos[0], pos[1], Stone_Radius2, stone_color)    pygame.gfxdraw.filled_circle(screen, pos[0], pos[1], Stone_Radius2, stone_color)

# 根据鼠标点击位置，返回游戏区坐标def _get_clickpoint(click_pos):    pos_x = click_pos[0] - Start_X    pos_y = click_pos[1] - Start_Y    if pos_x < -Inside_Width or pos_y < -Inside_Width:        return None    x = pos_x // SIZE    y = pos_y // SIZE    if pos_x % SIZE > Stone_Radius:        x += 1    if pos_y % SIZE > Stone_Radius:        y += 1    if x >= Line_Points or y >= Line_Points:        return None
    return Point(x, y)

class AI:    def __init__(self, line_points, chessman):        self._line_points = line_points        self._my = chessman        self._opponent = BLACK_CHESSMAN if chessman == WHITE_CHESSMAN else WHITE_CHESSMAN        self._checkerboard = [[0] * line_points for _ in range(line_points)]
    def get_opponent_drop(self, point):        self._checkerboard[point.Y][point.X] = self._opponent.Value
    def AI_drop(self):        point = None        score = 0        for i in range(self._line_points):            for j in range(self._line_points):                if self._checkerboard[j][i] == 0:                    _score = self._get_point_score(Point(i, j))                    if _score > score:                        score = _score                        point = Point(i, j)                    elif _score == score and _score > 0:                        r = random.randint(0, 100)                        if r % 2 == 0:                            point = Point(i, j)        self._checkerboard[point.Y][point.X] = self._my.Value        return point
    def _get_point_score(self, point):        score = 0        for os in offset:            score += self._get_direction_score(point, os[0], os[1])        return score
    def _get_direction_score(self, point, x_offset, y_offset):        count = 0   # 落子处我方连续子数        _count = 0  # 落子处对方连续子数        space = None   # 我方连续子中有无空格        _space = None  # 对方连续子中有无空格        both = 0    # 我方连续子两端有无阻挡        _both = 0   # 对方连续子两端有无阻挡
        # 如果是 1 表示是边上是我方子，2 表示敌方子        flag = self._get_stone_color(point, x_offset, y_offset, True)        if flag != 0:            for step in range(1, 6):                x = point.X + step * x_offset                y = point.Y + step * y_offset                if 0 <= x < self._line_points and 0 <= y < self._line_points:                    if flag == 1:                        if self._checkerboard[y][x] == self._my.Value:                            count += 1                            if space is False:                                space = True                        elif self._checkerboard[y][x] == self._opponent.Value:                            _both += 1                            break                        else:                            if space is None:                                space = False                            else:                                break   # 遇到第二个空格退出                    elif flag == 2:                        if self._checkerboard[y][x] == self._my.Value:                            _both += 1                            break                        elif self._checkerboard[y][x] == self._opponent.Value:                            _count += 1                            if _space is False:                                _space = True                        else:                            if _space is None:                                _space = False                            else:                                break                else:                    # 遇到边也就是阻挡                    if flag == 1:                        both += 1                    elif flag == 2:                        _both += 1
        if space is False:            space = None        if _space is False:            _space = None
        _flag = self._get_stone_color(point, -x_offset, -y_offset, True)        if _flag != 0:            for step in range(1, 6):                x = point.X - step * x_offset                y = point.Y - step * y_offset                if 0 <= x < self._line_points and 0 <= y < self._line_points:                    if _flag == 1:                        if self._checkerboard[y][x] == self._my.Value:                            count += 1                            if space is False:                                space = True                        elif self._checkerboard[y][x] == self._opponent.Value:                            _both += 1                            break                        else:                            if space is None:                                space = False                            else:                                break   # 遇到第二个空格退出                    elif _flag == 2:                        if self._checkerboard[y][x] == self._my.Value:                            _both += 1                            break                        elif self._checkerboard[y][x] == self._opponent.Value:                            _count += 1                            if _space is False:                                _space = True                        else:                            if _space is None:                                _space = False                            else:                                break                else:                    # 遇到边也就是阻挡                    if _flag == 1:                        both += 1                    elif _flag == 2:                        _both += 1
        score = 0        if count == 4:            score = 10000        elif _count == 4:            score = 9000        elif count == 3:            if both == 0:                score = 1000            elif both == 1:                score = 100            else:                score = 0        elif _count == 3:            if _both == 0:                score = 900            elif _both == 1:                score = 90            else:                score = 0        elif count == 2:            if both == 0:                score = 100            elif both == 1:                score = 10            else:                score = 0        elif _count == 2:            if _both == 0:                score = 90            elif _both == 1:                score = 9            else:                score = 0        elif count == 1:            score = 10        elif _count == 1:            score = 9        else:            score = 0
        if space or _space:            score /= 2
        return score
    # 判断指定位置处在指定方向上是我方子、对方子、空    def _get_stone_color(self, point, x_offset, y_offset, next):        x = point.X + x_offset        y = point.Y + y_offset        if 0 <= x < self._line_points and 0 <= y < self._line_points:            if self._checkerboard[y][x] == self._my.Value:                return 1            elif self._checkerboard[y][x] == self._opponent.Value:                return 2            else:                if next:                    return self._get_stone_color(Point(x, y), x_offset, y_offset, False)                else:                    return 0        else:            return 0

if __name__ == '__main__':    main()© 2019 GitHub, Inc.

ManAndMachine.py

"" "Gobang: Batalla hombre-máquina" ""

import sysimport randomimport pygamefrom pygame.locals import *import pygame.gfxdrawfrom checkerboard import Checkerboard, BLACK_CHESSMAN, WHITE_CHESSMAN, offset, Point
SIZE = 30  # 棋盘每个点时间的间隔Line_Points = 19  # 棋盘每行/每列点数Outer_Width = 20  # 棋盘外宽度Border_Width = 4  # 边框宽度Inside_Width = 4  # 边框跟实际的棋盘之间的间隔Border_Length = SIZE * (Line_Points - 1) + Inside_Width * 2 + Border_Width  # 边框线的长度Start_X = Start_Y = Outer_Width + int(Border_Width / 2) + Inside_Width  # 网格线起点（左上角）坐标SCREEN_HEIGHT = SIZE * (Line_Points - 1) + Outer_Width * 2 + Border_Width + Inside_Width * 2  # 游戏屏幕的高SCREEN_WIDTH = SCREEN_HEIGHT + 200  # 游戏屏幕的宽
Stone_Radius = SIZE // 2 - 3  # 棋子半径Stone_Radius2 = SIZE // 2 + 3Checkerboard_Color = (0xE3, 0x92, 0x65)  # 棋盘颜色BLACK_COLOR = (0, 0, 0)WHITE_COLOR = (255, 255, 255)RED_COLOR = (200, 30, 30)BLUE_COLOR = (30, 30, 200)
RIGHT_INFO_POS_X = SCREEN_HEIGHT + Stone_Radius2 * 2 + 10

def print_text(screen, font, x, y, text, fcolor=(255, 255, 255)):    imgText = font.render(text, True, fcolor)    screen.blit(imgText, (x, y))

def main():    pygame.init()    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))    pygame.display.set_caption('五子棋')
    font1 = pygame.font.SysFont('SimHei', 32)    font2 = pygame.font.SysFont('SimHei', 72)    fwidth, fheight = font2.size('黑方获胜')
    checkerboard = Checkerboard(Line_Points)    cur_runner = BLACK_CHESSMAN    winner = None    computer = AI(Line_Points, WHITE_CHESSMAN)
    black_win_count = 0    white_win_count = 0
    while True:        for event in pygame.event.get():            if event.type == QUIT:                sys.exit()            elif event.type == KEYDOWN:                if event.key == K_RETURN:                    if winner is not None:                        winner = None                        cur_runner = BLACK_CHESSMAN                        checkerboard = Checkerboard(Line_Points)                        computer = AI(Line_Points, WHITE_CHESSMAN)            elif event.type == MOUSEBUTTONDOWN:                if winner is None:                    pressed_array = pygame.mouse.get_pressed()                    if pressed_array[0]:                        mouse_pos = pygame.mouse.get_pos()                        click_point = _get_clickpoint(mouse_pos)                        if click_point is not None:                            if checkerboard.can_drop(click_point):                                winner = checkerboard.drop(cur_runner, click_point)                                if winner is None:                                    cur_runner = _get_next(cur_runner)                                    computer.get_opponent_drop(click_point)                                    AI_point = computer.AI_drop()                                    winner = checkerboard.drop(cur_runner, AI_point)                                    if winner is not None:                                        white_win_count += 1                                    cur_runner = _get_next(cur_runner)                                else:                                    black_win_count += 1                        else:                            print('超出棋盘区域')
        # 画棋盘        _draw_checkerboard(screen)
        # 画棋盘上已有的棋子        for i, row in enumerate(checkerboard.checkerboard):            for j, cell in enumerate(row):                if cell == BLACK_CHESSMAN.Value:                    _draw_chessman(screen, Point(j, i), BLACK_CHESSMAN.Color)                elif cell == WHITE_CHESSMAN.Value:                    _draw_chessman(screen, Point(j, i), WHITE_CHESSMAN.Color)
        _draw_left_info(screen, font1, cur_runner, black_win_count, white_win_count)
        if winner:            print_text(screen, font2, (SCREEN_WIDTH - fwidth)//2, (SCREEN_HEIGHT - fheight)//2, winner.Name + '获胜', RED_COLOR)
        pygame.display.flip()

def _get_next(cur_runner):    if cur_runner == BLACK_CHESSMAN:        return WHITE_CHESSMAN    else:        return BLACK_CHESSMAN

# 画棋盘def _draw_checkerboard(screen):    # 填充棋盘背景色    screen.fill(Checkerboard_Color)    # 画棋盘网格线外的边框    pygame.draw.rect(screen, BLACK_COLOR, (Outer_Width, Outer_Width, Border_Length, Border_Length), Border_Width)    # 画网格线    for i in range(Line_Points):        pygame.draw.line(screen, BLACK_COLOR,                         (Start_Y, Start_Y + SIZE * i),                         (Start_Y + SIZE * (Line_Points - 1), Start_Y + SIZE * i),                         1)    for j in range(Line_Points):        pygame.draw.line(screen, BLACK_COLOR,                         (Start_X + SIZE * j, Start_X),                         (Start_X + SIZE * j, Start_X + SIZE * (Line_Points - 1)),                         1)    # 画星位和天元    for i in (3, 9, 15):        for j in (3, 9, 15):            if i == j == 9:                radius = 5            else:                radius = 3            # pygame.draw.circle(screen, BLACK, (Start_X + SIZE * i, Start_Y + SIZE * j), radius)            pygame.gfxdraw.aacircle(screen, Start_X + SIZE * i, Start_Y + SIZE * j, radius, BLACK_COLOR)            pygame.gfxdraw.filled_circle(screen, Start_X + SIZE * i, Start_Y + SIZE * j, radius, BLACK_COLOR)

# 画棋子def _draw_chessman(screen, point, stone_color):    # pygame.draw.circle(screen, stone_color, (Start_X + SIZE * point.X, Start_Y + SIZE * point.Y), Stone_Radius)    pygame.gfxdraw.aacircle(screen, Start_X + SIZE * point.X, Start_Y + SIZE * point.Y, Stone_Radius, stone_color)    pygame.gfxdraw.filled_circle(screen, Start_X + SIZE * point.X, Start_Y + SIZE * point.Y, Stone_Radius, stone_color)

# 画左侧信息显示def _draw_left_info(screen, font, cur_runner, black_win_count, white_win_count):    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, Start_X + Stone_Radius2), BLACK_CHESSMAN.Color)    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, Start_X + Stone_Radius2 * 4), WHITE_CHESSMAN.Color)
    print_text(screen, font, RIGHT_INFO_POS_X, Start_X + 3, '玩家', BLUE_COLOR)    print_text(screen, font, RIGHT_INFO_POS_X, Start_X + Stone_Radius2 * 3 + 3, '电脑', BLUE_COLOR)
    print_text(screen, font, SCREEN_HEIGHT, SCREEN_HEIGHT - Stone_Radius2 * 8, '战况：', BLUE_COLOR)    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, SCREEN_HEIGHT - int(Stone_Radius2 * 4.5)), BLACK_CHESSMAN.Color)    _draw_chessman_pos(screen, (SCREEN_HEIGHT + Stone_Radius2, SCREEN_HEIGHT - Stone_Radius2 * 2), WHITE_CHESSMAN.Color)    print_text(screen, font, RIGHT_INFO_POS_X, SCREEN_HEIGHT - int(Stone_Radius2 * 5.5) + 3, f'{black_win_count} 胜', BLUE_COLOR)    print_text(screen, font, RIGHT_INFO_POS_X, SCREEN_HEIGHT - Stone_Radius2 * 3 + 3, f'{white_win_count} 胜', BLUE_COLOR)

def _draw_chessman_pos(screen, pos, stone_color):    pygame.gfxdraw.aacircle(screen, pos[0], pos[1], Stone_Radius2, stone_color)    pygame.gfxdraw.filled_circle(screen, pos[0], pos[1], Stone_Radius2, stone_color)

# 根据鼠标点击位置，返回游戏区坐标def _get_clickpoint(click_pos):    pos_x = click_pos[0] - Start_X    pos_y = click_pos[1] - Start_Y    if pos_x < -Inside_Width or pos_y < -Inside_Width:        return None    x = pos_x // SIZE    y = pos_y // SIZE    if pos_x % SIZE > Stone_Radius:        x += 1    if pos_y % SIZE > Stone_Radius:        y += 1    if x >= Line_Points or y >= Line_Points:        return None
    return Point(x, y)

class AI:    def __init__(self, line_points, chessman):        self._line_points = line_points        self._my = chessman        self._opponent = BLACK_CHESSMAN if chessman == WHITE_CHESSMAN else WHITE_CHESSMAN        self._checkerboard = [[0] * line_points for _ in range(line_points)]
    def get_opponent_drop(self, point):        self._checkerboard[point.Y][point.X] = self._opponent.Value
    def AI_drop(self):        point = None        score = 0        for i in range(self._line_points):            for j in range(self._line_points):                if self._checkerboard[j][i] == 0:                    _score = self._get_point_score(Point(i, j))                    if _score > score:                        score = _score                        point = Point(i, j)                    elif _score == score and _score > 0:                        r = random.randint(0, 100)                        if r % 2 == 0:                            point = Point(i, j)        self._checkerboard[point.Y][point.X] = self._my.Value        return point
    def _get_point_score(self, point):        score = 0        for os in offset:            score += self._get_direction_score(point, os[0], os[1])        return score
    def _get_direction_score(self, point, x_offset, y_offset):        count = 0   # 落子处我方连续子数        _count = 0  # 落子处对方连续子数        space = None   # 我方连续子中有无空格        _space = None  # 对方连续子中有无空格        both = 0    # 我方连续子两端有无阻挡        _both = 0   # 对方连续子两端有无阻挡
        # 如果是 1 表示是边上是我方子，2 表示敌方子        flag = self._get_stone_color(point, x_offset, y_offset, True)        if flag != 0:            for step in range(1, 6):                x = point.X + step * x_offset                y = point.Y + step * y_offset                if 0 <= x < self._line_points and 0 <= y < self._line_points:                    if flag == 1:                        if self._checkerboard[y][x] == self._my.Value:                            count += 1                            if space is False:                                space = True                        elif self._checkerboard[y][x] == self._opponent.Value:                            _both += 1                            break                        else:                            if space is None:                                space = False                            else:                                break   # 遇到第二个空格退出                    elif flag == 2:                        if self._checkerboard[y][x] == self._my.Value:                            _both += 1                            break                        elif self._checkerboard[y][x] == self._opponent.Value:                            _count += 1                            if _space is False:                                _space = True                        else:                            if _space is None:                                _space = False                            else:                                break                else:                    # 遇到边也就是阻挡                    if flag == 1:                        both += 1                    elif flag == 2:                        _both += 1
        if space is False:            space = None        if _space is False:            _space = None
        _flag = self._get_stone_color(point, -x_offset, -y_offset, True)        if _flag != 0:            for step in range(1, 6):                x = point.X - step * x_offset                y = point.Y - step * y_offset                if 0 <= x < self._line_points and 0 <= y < self._line_points:                    if _flag == 1:                        if self._checkerboard[y][x] == self._my.Value:                            count += 1                            if space is False:                                space = True                        elif self._checkerboard[y][x] == self._opponent.Value:                            _both += 1                            break                        else:                            if space is None:                                space = False                            else:                                break   # 遇到第二个空格退出                    elif _flag == 2:                        if self._checkerboard[y][x] == self._my.Value:                            _both += 1                            break                        elif self._checkerboard[y][x] == self._opponent.Value:                            _count += 1                            if _space is False:                                _space = True                        else:                            if _space is None:                                _space = False                            else:                                break                else:                    # 遇到边也就是阻挡                    if _flag == 1:                        both += 1                    elif _flag == 2:                        _both += 1
        score = 0        if count == 4:            score = 10000        elif _count == 4:            score = 9000        elif count == 3:            if both == 0:                score = 1000            elif both == 1:                score = 100            else:                score = 0        elif _count == 3:            if _both == 0:                score = 900            elif _both == 1:                score = 90            else:                score = 0        elif count == 2:            if both == 0:                score = 100            elif both == 1:                score = 10            else:                score = 0        elif _count == 2:            if _both == 0:                score = 90            elif _both == 1:                score = 9            else:                score = 0        elif count == 1:            score = 10        elif _count == 1:            score = 9        else:            score = 0
        if space or _space:            score /= 2
        return score
    # 判断指定位置处在指定方向上是我方子、对方子、空    def _get_stone_color(self, point, x_offset, y_offset, next):        x = point.X + x_offset        y = point.Y + y_offset        if 0 <= x < self._line_points and 0 <= y < self._line_points:            if self._checkerboard[y][x] == self._my.Value:                return 1            elif self._checkerboard[y][x] == self._opponent.Value:                return 2            else:                if next:                    return self._get_stone_color(Point(x, y), x_offset, y_offset, False)                else:                    return 0        else:            return 0

if __name__ == '__main__':    main()

checkerboard.pyfrom colecciones importación namedtuple

Chessman = namedtuple('Chessman', 'Name Value Color')Point = namedtuple('Point', 'X Y')
BLACK_CHESSMAN = Chessman('黑子', 1, (45, 45, 45))WHITE_CHESSMAN = Chessman('白子', 2, (219, 219, 219))
offset = [(1, 0), (0, 1), (1, 1), (1, -1)]

class Checkerboard:    def __init__(self, line_points):        self._line_points = line_points        self._checkerboard = [[0] * line_points for _ in range(line_points)]
    def _get_checkerboard(self):        return self._checkerboard
    checkerboard = property(_get_checkerboard)
    # 判断是否可落子    def can_drop(self, point):        return self._checkerboard[point.Y][point.X] == 0
    def drop(self, chessman, point):        """        落子        :param chessman:        :param point:落子位置        :return:若该子落下之后即可获胜，则返回获胜方，否则返回 None        """        print(f'{chessman.Name} ({point.X}, {point.Y})')        self._checkerboard[point.Y][point.X] = chessman.Value
        if self._win(point):            print(f'{chessman.Name}获胜')            return chessman
    # 判断是否赢了    def _win(self, point):        cur_value = self._checkerboard[point.Y][point.X]        for os in offset:            if self._get_count_on_direction(point, cur_value, os[0], os[1]):                return True
    def _get_count_on_direction(self, point, value, x_offset, y_offset):        count = 1        for step in range(1, 5):            x = point.X + step * x_offset            y = point.Y + step * y_offset            if 0 <= x < self._line_points and 0 <= y < self._line_points and self._checkerboard[y][x] == value:                count += 1            else:                break        for step in range(1, 5):            x = point.X - step * x_offset            y = point.Y - step * y_offset            if 0 <= x < self._line_points and 0 <= y < self._line_points and self._checkerboard[y][x] == value:                count += 1            else:                break
        return count >= 5

imagen

Supongo que te gusta

Origin blog.csdn.net/Python_kele/article/details/115147664
Recomendado
Clasificación
Diario
Más
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)

Code World

© 2018 codetd.com