python实现翻转棋游戏(othello)

利用上一篇的框架,再写了个翻转棋的程序,为了调试minimax算法,花了两天的时间。

几点改进说明:

  • 拆分成四个文件:board.py,player.py,ai.py,othello.py。使得整个结构更清晰,更通用,更易于维护。
  • AI 的水平跟 minimax 的递归深度,以及评价函数有关。基于此,我把 minimax 和评价函数都放到 AI 类里面
  • AIPlayer 使用了多重继承。继承了 Player 与 AI 两个类
  • Game 类中把原run函数里的生成两个玩家的部分提出来,写成一个函数make_two_players,使得 run函数结构更清晰
  • AI 玩家等级不要选择 0:beginer。会报错,还没调试好

board.py

'''
作者:hhh5460
时间:2017年7月1日
'''

class Board(object):
 def __init__(self):
  self.empty = '.'
  self._board = [[self.empty for _ in range(8)] for _ in range(8)] # 规格:8*8
  self._board[3][4], self._board[4][3] = 'X', 'X'
  self._board[3][3], self._board[4][4] = 'O', 'O'

 # 增加 Board[][] 索引语法
 def __getitem__(self, index):
  return self._board[index]

 # 打印棋盘
 def print_b(self):
  board = self._board
  print(' ', ' '.join(list('ABCDEFGH')))
  for i in range(8):
   print(str(i+1),' '.join(board[i]))

 # 棋局终止
 def teminate(self):
  list1 = list(self.get_legal_actions('X'))
  list2 = list(self.get_legal_actions('O'))
  return [False, True][len(list1) == 0 and len(list2) == 0]

 # 判断赢家
 def get_winner(self):
  s1, s2 = 0, 0
  for i in range(8):
   for j in range(8):
    if self._board[i][j] == 'X':
     s1 += 1
    if self._board[i][j] == 'O':
     s2 += 1
  if s1 > s2:
   return 0 # 黑胜
  elif s1 < s2:
   return 1 # 白胜
  elif s1 == s2:
   return 2 # 平局
 # 落子
 def _move(self, action, color):
  x,y = action
  self._board[x][y] = color

  return self._flip(action, color)

 # 翻子(返回list)
 def _flip(self, action, color):
  flipped_pos = []

  for line in self._get_lines(action):
   for i,p in enumerate(line):
    if self._board[p[0]][p[1]] == self.empty:
     break
    elif self._board[p[0]][p[1]] == color:
     flipped_pos.extend(line[:i])
     break

  for p in flipped_pos:
   self._board[p[0]][p[1]] = color

  return flipped_pos

 # 撤销
 def _unmove(self, action, flipped_pos, color):
  self._board[action[0]][action[1]] = self.empty

  uncolor = ['X', 'O'][color=='X']
  for p in flipped_pos:
   self._board[p[0]][p[1]] = uncolor

 # 生成8个方向的下标数组,方便后续操作
 def _get_lines(self, action):
  '''说明:刚开始我是用一维棋盘来考虑的,后来改为二维棋盘。偷懒,不想推倒重来,简单地修改了一下'''
  board_coord = [(i,j) for i in range(8) for j in range(8)] # 棋盘坐标

  r,c = action
  ix = r*8 + c
  r, c = ix//8, ix%8
  left = board_coord[r*8:ix] # 要反转
  right = board_coord[ix+1:(r+1)*8]
  top = board_coord[c:ix:8] # 要反转
  bottom = board_coord[ix+8:8*8:8]

  if r <= c:
   lefttop = board_coord[c-r:ix:9] # 要反转
   rightbottom = board_coord[ix+9:(7-(c-r))*8+7+1:9]
  else:
   lefttop = board_coord[(r-c)*8:ix:9] # 要反转
   rightbottom = board_coord[ix+9:7*8+(7-(c-r))+1:9]

  if r+c<=7:
   leftbottom = board_coord[ix+7:(r+c)*8:7]
   righttop = board_coord[r+c:ix:7] # 要反转
  else:
   leftbottom = board_coord[ix+7:7*8+(r+c)-7+1:7]
   righttop = board_coord[((r+c)-7)*8+7:ix:7] # 要反转

  # 有四个要反转,方便判断
  left.reverse()
  top.reverse()
  lefttop.reverse()
  righttop.reverse()
  lines = [left, top, lefttop, righttop, right, bottom, leftbottom, rightbottom]
  return lines

 # 检测,位置是否有子可翻
 def _can_fliped(self, action, color):
  flipped_pos = []

  for line in self._get_lines(action):
   for i,p in enumerate(line):
    if self._board[p[0]][p[1]] == self.empty:
     break
    elif self._board[p[0]][p[1]] == color:
     flipped_pos.extend(line[:i])
     break
  return [False, True][len(flipped_pos) > 0]

 # 合法走法
 def get_legal_actions(self, color):
  uncolor = ['X', 'O'][color=='X']
  uncolor_near_points = [] # 反色邻近的空位

  board = self._board
  for i in range(8):
   for j in range(8):
    if board[i][j] == uncolor:
     for dx,dy in [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1)]:
      x, y = i+dx, j+dy
      if 0 <= x <=7 and 0 <= y <=7 and board[x][y] == self.empty and (x, y) not in uncolor_near_points:
       uncolor_near_points.append((x, y))
  for p in uncolor_near_points:
   if self._can_fliped(p, color):
    yield p

# 测试
if __name__ == '__main__':
 board = Board()
 board.print_b()
 print(list(board.get_legal_actions('X')))

player.py

from ai import AI

'''
作者:hhh5460
时间:2017年7月1日
'''

# 玩家
class Player(object):
 def __init__(self, color):
  self.color = color

 # 思考
 def think(self, board):
  pass

 # 落子
 def move(self, board, action):
  flipped_pos = board._move(action, self.color)
  return flipped_pos

 # 悔子
 def unmove(self, board, action, flipped_pos):
  board._unmove(action, flipped_pos, self.color)

# 人类玩家
class HumanPlayer(Player):
 def __init__(self, color):
  super().__init__(color)

 def think(self, board):
  while True:
   action = input("Turn to '{}'. \nPlease input a point.(such as 'A1'): ".format(self.color)) # A1~H8
   r, c = action[1], action[0].upper()
   if r in '12345678' and c in 'ABCDEFGH': # 合法性检查1
    x, y = '12345678'.index(r), 'ABCDEFGH'.index(c)
    if (x,y) in board.get_legal_actions(self.color): # 合法性检查2
     return x, y

# 电脑玩家(多重继承)
class AIPlayer(Player, AI):

 def __init__(self, color, level_ix=0):
  super().__init__(color)    # init Player
  super(Player, self).__init__(level_ix) # init AI

 def think(self, board):
  print("Turn to '{}'. \nPlease wait a moment. AI is thinking...".format(self.color))
  uncolor = ['X','O'][self.color=='X']
  opfor = AIPlayer(uncolor) # 假想敌,陪练
  action = self.brain(board, opfor, 4)
  return action

ai.py

import random

'''
作者:hhh5460
时间:2017年7月1日
'''

class AI(object):
 '''
 三个水平等级:初级(beginner)、中级(intermediate)、高级(advanced)
 '''
 def __init__(self, level_ix =0):
  # 玩家等级
  self.level = ['beginner','intermediate','advanced'][level_ix]
  # 棋盘位置权重,参考:https://github.com/k-time/ai-minimax-agent/blob/master/ksx2101.py
  self.board_weights = [
   [120, -20, 20, 5, 5, 20, -20, 120],
   [-20, -40, -5, -5, -5, -5, -40, -20],
   [ 20, -5, 15, 3, 3, 15, -5, 20],
   [ 5, -5, 3, 3, 3, 3, -5, 5],
   [ 5, -5, 3, 3, 3, 3, -5, 5],
   [ 20, -5, 15, 3, 3, 15, -5, 20],
   [-20, -40, -5, -5, -5, -5, -40, -20],
   [120, -20, 20, 5, 5, 20, -20, 120]
  ]

 # 评估函数(仅根据棋盘位置权重)
 def evaluate(self, board, color):
  uncolor = ['X','O'][color=='X']
  score = 0
  for i in range(8):
   for j in range(8):
    if board[i][j] == color:
     score += self.board_weights[i][j]
    elif board[i][j] == uncolor:
     score -= self.board_weights[i][j]
  return score

 # AI的大脑
 def brain(self, board, opponent, depth):
  if self.level == 'beginer':   # 初级水平
   _, action = self.randomchoice(board)
  elif self.level == 'intermediate': # 中级水平
   _, action = self.minimax(board, opponent, depth)
  elif self.level == 'advanced':  # 高级水平
   _, action = self.minimax_alpha_beta(board, opponent, depth)
  assert action is not None, 'action is None'
  return action

 # 随机选(从合法走法列表中随机选)
 def randomchoice(self, board):
  color = self.color
  action_list = list(board.get_legal_actions(color))
  return None, random.choice(action_list)

 # 极大极小算法,限制深度
 def minimax(self, board, opfor, depth=4): # 其中 opfor 是假想敌、陪练
  '''参考:https://github.com/k-time/ai-minimax-agent/blob/master/ksx2101.py'''
  color = self.color

  if depth == 0:
   return self.evaluate(board, color), None

  action_list = list(board.get_legal_actions(color))
  if not action_list:
   return self.evaluate(board, color), None

  best_score = -100000
  best_action = None

  for action in action_list:
   flipped_pos = self.move(board, action) # 落子
   score, _ = opfor.minimax(board, self, depth-1) # 深度优先,轮到陪练
   self.unmove(board, action, flipped_pos) # 回溯

   score = -score
   if score > best_score:
    best_score = score
    best_action = action

  return best_score, best_action

 # 极大极小算法,带alpha-beta剪枝
 def minimax_alpha_beta(self, board, opfor, depth=8, my_best=-float('inf'), opp_best=float('inf')):
  '''参考:https://github.com/k-time/ai-minimax-agent/blob/master/ksx2101.py'''
  color = self.color

  if depth == 0:
   return self.evaluate(board, color), None

  action_list = list(board.get_legal_actions(color))
  if not action_list:
   return self.evaluate(board, color), None

  best_score = my_best
  best_action = None

  for action in action_list:
   flipped_pos = self.move(board, action) # 落子
   score, _ = opfor.minimax_alpha_beta(board, self, depth-1, -opp_best, -best_score) # 深度优先,轮到陪练
   self.unmove(board, action, flipped_pos) # 回溯

   score = -score
   if score > best_score:
    best_score = score
    best_action = action

   if best_score > opp_best:
    break

  return best_score, best_action

othello.py

from board import Board
from player import HumanPlayer, AIPlayer

'''
作者:hhh5460
时间:2017年7月1日
'''

# 游戏
class Game(object):
 def __init__(self):
  self.board = Board()
  self.current_player = None

 # 生成两个玩家
 def make_two_players(self):
  ps = input("Please select two player's type:\n\t0.Human\n\t1.AI\nSuch as:0 0\n:")
  p1, p2 = [int(p) for p in ps.split(' ')]
  if p1 == 1 or p2 == 1: # 至少有一个AI玩家
   level_ix = int(input("Please select the level of AI player.\n\t0: beginner\n\t1: intermediate\n\t2: advanced\n:"))
   if p1 == 0:
    player1 = HumanPlayer('X')
    player2 = AIPlayer('O', level_ix)
   elif p2 == 0:
    player1 = AIPlayer('X', level_ix)
    player2 = HumanPlayer('O')
   else:
    player1 = AIPlayer('X', level_ix)
    player2 = AIPlayer('O', level_ix)
  else:
   player1, player2 = HumanPlayer('X'), HumanPlayer('O') # 先手执X,后手执O

  return player1, player2

 # 切换玩家(游戏过程中)
 def switch_player(self, player1, player2):
  if self.current_player is None:
   return player1
  else:
   return [player1, player2][self.current_player == player1]

 # 打印赢家
 def print_winner(self, winner): # winner in [0,1,2]
  print(['Winner is player1','Winner is player2','Draw'][winner])

 # 运行游戏
 def run(self):
  # 生成两个玩家
  player1, player2 = self.make_two_players()

  # 游戏开始
  print('\nGame start!\n')
  self.board.print_b() # 显示棋盘
  while True:
   self.current_player = self.switch_player(player1, player2) # 切换当前玩家

   action = self.current_player.think(self.board) # 当前玩家对棋盘进行思考后,得到招法

   if action is not None:
    self.current_player.move(self.board, action) # 当前玩家执行招法,改变棋盘

   self.board.print_b() # 显示当前棋盘

   if self.board.teminate(): # 根据当前棋盘,判断棋局是否终止
    winner = self.board.get_winner() # 得到赢家 0,1,2
    break

  self.print_winner(winner)
  print('Game over!')

  self.board.print_history()

if __name__ == '__main__':
 Game().run()

效果图

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • python实现五子棋小游戏

    本文实例为大家分享了python实现五子棋小游戏的具体代码,供大家参考,具体内容如下 暑假学了十几天python,然后用pygame模块写了一个五子棋的小游戏,代码跟有缘人分享一下. import numpy as np import pygame import sys import traceback import copy from pygame.locals import * pygame.init() pygame.mixer.init() #颜色 background=(201,202

  • python使用tkinter库实现五子棋游戏

    本文实例为大家分享了python实现五子棋游戏的具体代码,供大家参考,具体内容如下 一.运行截图: 二.代码 # 用数组定义一个棋盘,棋盘大小为 15×15 # 数组索引代表位置, # 元素值代表该位置的状态:0代表没有棋子,1代表有黑棋,-1代表有白棋. from tkinter import * from tkinter.messagebox import * class Chess(object): def __init__(self): ############# # param # #

  • python实现五子棋人机对战游戏

    本文代码基于 python3.6 和 pygame1.9.4. 五子棋比起我之前写的几款游戏来说,难度提高了不少.如果是人与人对战,那么,电脑只需要判断是否赢了就可以.如果是人机对战,那你还得让电脑知道怎么下. 我们先从简单的问题来看. 开端 画棋盘 首先肯定是要画出棋盘来,用 pygame 画出一个 19 × 19 或 15 × 15 的棋盘并不是什么难事,这在之前的文章中已经多次用到,就不赘述了. 画棋子 需要说一下的是画棋子,因为没找到什么合适的棋子图片,所以只要自己来画棋子. 我们用 p

  • python实现简单五子棋游戏

    本文实例为大家分享了python实现简单五子棋游戏的具体代码,供大家参考,具体内容如下 from graphics import * from math import * import numpy as np def ai(): """ AI计算落子位置 """ maxmin(True, DEPTH, -99999999, 99999999) return next_point[0], next_point[1] def maxmin(is_ai

  • 使用python实现简单五子棋游戏

    用python实现五子棋简单人机模式的练习过程,供大家参考,具体内容如下 第一次写博客,我尽力把它写好. 最近在初学python,今天就用自己的一些粗浅理解,来记录一下这几天的python简单人机五子棋游戏的练习,下面是实现过程的理解(是在cmd中运行的): 主要流程: *重点内容* - 首先是模块及类的划分 - 棋子类和棋盘类的方法 - 对策略类里的功能进行细分,调用棋子类和棋盘类 - 写出判断输赢的方法 - 用main函数进行整个游戏进度的控制 模块及类的划分 类的划分涉及到了面向对象的内容

  • python实现井字棋游戏

    本文实例介绍了python实现井字棋游戏的方法,分享给大家,具体内容如下 windows7下python3.4.0编译运行通过.由于采用了cmd调用,所以与Linux不兼容,无法在Linux下运行. 游戏就是井字棋,小键盘上的数字位置对应棋盘位置. #本游戏python3.4.0下编写调试,只能在windows下运行. import random import subprocess import time #定义函数 def draw_board(the_board): subprocess.c

  • python实现五子棋游戏

    本文实例为大家分享了python实现五子棋游戏的具体代码,供大家参考,具体内容如下 话不多说,直接上代码: 全部工程文件,在GitHub:五子棋 效果预览: #!/usr/bin/env python3 #-*- coding:utf-8 -*- import pygame from pygame.locals import * from sys import exit import numpy background_image = 'qipan.png' white_image = 'whit

  • python pygame实现五子棋小游戏

    今天学习了如何使用pygame来制作小游戏,下面是五子棋的代码,我的理解都写在注释里了 import pygame # 导入pygame模块 print(pygame.ver) # 检查pygame的版本,检查pygame有没有导入成功 EMPTY = 0 BLACK = 1 WHITE = 2 # 定义三个常量函数,用来表示白棋,黑棋,以及 空 black_color = [0, 0, 0] # 定义黑色(黑棋用,画棋盘) white_color = [255, 255, 255] # 定义白

  • python制作简单五子棋游戏

    本文实例为大家分享了python五子棋游戏的具体代码,供大家参考,具体内容如下 #五子棋 ''' 矩阵做棋盘 16*16 "+" 打印棋盘 for for 游戏是否结束 开始下棋 while 游戏是否结束: 黑白交替 player=0 p%2==0 ==1 p+=1 下棋动作一样 但是棋子不一样 ''' 代码 #创建棋盘的程序 def initBoard(): global board #调用全局的board board=[None]*16 for i in range(len(boa

  • python五子棋游戏的设计与实现

    这个python的小案例是五子棋游戏的实现,在这个案例中,我们可以实现五子棋游戏的两个玩家在指定的位置落子,画出落子后的棋盘,并且根据函数判断出输赢的功能. 这个案例的思路如下所示: 首先,根据棋盘的样子画出棋盘 然后,对棋盘进行初始化,将可以落子的位置进行统一化处理 接下来,就是进入游戏的环节,双方轮流落子,落子后,并将棋盘画出 最后,根据落子的位置判断选手的的输赢情况,游戏结束 五子棋游戏的设计和实现 代码如下: def main(): print("五子棋游戏".center(5

  • Python实现的井字棋(Tic Tac Toe)游戏示例

    本文实例讲述了Python实现的井字棋(Tic Tac Toe)游戏.分享给大家供大家参考,具体如下: 说明 用python实现了井字棋,整个框架是本人自己构思的,自认为比较满意.另外,90%+的代码也是本人逐字逐句敲的. minimax算法还没完全理解,所以参考了这里的代码,并作了修改. 特点 可以选择人人.人机.机人.机机四种对战模式之一 电脑玩家的AI使用了minimax算法,带apha-beta剪枝 电脑玩家在思考时,时时刻刻都有一个"假想敌".以便使得minimax算法运转起

随机推荐