python实现五子棋游戏,怎么做五子棋游戏

  python实现五子棋游戏,怎么做五子棋游戏

  这篇文章主要为大家详细介绍了简介及安装实现简单五子棋游戏,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下溴

  本文实例为大家分享了简介及安装实现简单五子棋游戏的具体代码,供大家参考,具体内容如下

  看代码:

  Gomuku2.py:

  导入系统

  随机导入

  导入简介及安装

  从pygame.locals导入*

  导入pygame.gfxdraw

  从棋盘导入棋盘,黑色棋子,白色棋子,偏移,点

  尺寸=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 3

  Checkerboard_Color=(0xE3,0x92,0x65) #棋盘颜色

  黑色_颜色=(0,0,0)

  白色_颜色=(255,255,255)

  红色=(200,30,30)

  BLUE_COLOR=(30,30,200)

  RIGHT _ INFO _ POS _ X=SCREEN _ HEIGHT Stone _ radius 2 * 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))

  定义主():

  pygame.init()

  屏幕=py游戏。展示。set _ mode((屏幕_宽度,屏幕_高度))

  pygame.display.set_caption(五子棋)

  font 1=py游戏。字体。系统字体(“sim hei”,32)

  font 2=py游戏。字体。系统字体(“sim hei”,72)

  fwidth,FH height=font 2。大小(黑方获胜)

  棋盘=棋盘(线点)

  cur_runner=黑色_棋子

  获胜者=无

  电脑=AI(线_点,白_棋子)

  black _ win _计数=0

  怀特赢数=0

  而True:

  用于pygame.event.get():中的事件

  if event.type==QUIT:

  sys.exit()

  elif event.type==KEYDOWN:

  if event.key==K_RETURN:

  如果获胜者不是:

  获胜者=无

  cur_runner=黑色_棋子

  棋盘=棋盘(线点)

  电脑=AI(线_点,白_棋子)

              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.py:

  

from collections import 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

  

  以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持盛行IT软件开发工作室。

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: