设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › Python交流 › Python五子棋,第一版（弱智电脑）
返回列表 发新帖
查看: 2674|回复: 3

[技术交流] Python五子棋,第一版（弱智电脑）

[复制链接]
Stubborn
发表于 2021-2-16 21:45:30 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
Python五子棋


version:1.0
  • 功能介绍：基本实现五子棋功能，判定棋型，给予得分，因为评分机制，导致防御还可以，进攻就和弱智差不多了
  • Model.py>>>主要实现的基本功能都在这里
  • checkerboard.py>>>和界面UI的交互，待下一版实现
  • cmd_board>>>测试用，cmd的打印界面
  • setting.py>>>全局变量设置的保存


version:1.1准备实现alpha_beta剪枝搜索，有大佬会的吗？


  1. # -*- coding: utf-8 -*-
  2. # !/usr/bin/python3
  3. """
  4. @ version: ??
  5. @ author: Alex
  6. @ file: Model
  7. @ datetime: 2021/02/09 - 14:08
  8. @ explain:
  9. """
  10. from setting import SIZE, ChessType, COMPUTER, PLAYER, VECTOR
  11. from CoreCode.tools import LogHandler

  13. from typing import List, Set, Tuple
  14. from itertools import chain

  16. # TODO =============== 数据类型声明 =============
  17. # 坐标着点 x
  18. X: int = int()
  19. # 坐标着点 y
  20. Y: int = int()
  21. # 坐标
  22. Point: tuple = (X, Y)


  25. class GoBangBase:
  26.     """棋盘数据和得分规则管理
  27.         GoBangData实现
  28.                 对落子的存储，采用的hash字典存储 self[x,y] = Computer or Player
  29.             ::data -> 五子棋的数据储存
  30.             ::one_spot -> 待搜索的点
  31.                 所有已落子的八个方向，延伸5个点位。不包括已落子和超出边界的子

  33.             def _result(self, p) -> List[str]:
  34.                 获取 p 点四个方向（xy轴及左右斜轴）的落子数据，拼接成字符串返回

  36.             def get_xy_score(self, spot:List[int], flag: str) -> int:
  37.                 获取 spot 落点的具体评分

  39.             def update_one(self, p: List[int]) -> Set[tuple]:
  40.                 获得p落点周围八个方位总计40个点，排除已落子和超出边界的点

  42.             def evaluation(self) -> Tuple[int, Point]:
  43.                 对当前局面进行评价，获得敌我双方最大的收益点。

  45.     """
  46.     data = dict().fromkeys(range(SIZE * SIZE), "0")
  47.     one_spot: set = set()
  48.     vector = chain.from_iterable(list(chain.from_iterable(VECTOR)))

  50.     @staticmethod
  51.     def key(x: X, y: Y): return x * SIZE + y

  53.     # TODO 筛选超出边界的点
  54.     def f(self, p: Point):
  55.         """
  56.         对着点的筛选，A:没有超出边界. B:没有进行落子. C:不在待搜索的列表
  57.         :param p:
  58.         :return:
  59.         """
  60.         if -1 < p[0] < SIZE and -1 < p[1] < SIZE:
  61.             if p in self and p not in self.one_spot:
  62.                 return True
  63.         return False

  65.     def __getitem__(self, key: Point) -> str:
  66.         """
  67.         :param key: List[int, int] -> [x, y]  落点的坐标
  68.         :return: 落点的数据 '0'=空白 '1' or '2' 已经落子
  69.         """
  70.         if -1 < key[0] < SIZE and -1 < key[1] < SIZE:
  71.             return self.data[self.key(*key)]
  72.         return ""

  74.     def __setitem__(self, key: Point, value: str):
  75.         """
  76.         :param key: Set(int, int) -> [x, y]  落点的坐标
  77.         :param value: 落点的数据  1 or 2 玩家或者电脑AI
  78.         :return: None
  79.         """
  80.         self.data[self.key(*key)] = value

  82.     def __contains__(self, key):
  83.         """
  84.         :param key: List[int, int] -> [x, y]  落点的坐标
  85.         :return: bool ->判断当前点是否可以落子
  86.         """
  87.         return self[key] == "0"

  89.     def _result(self, p: Point) -> List[str]:
  90.         """
  91.         :param p: 五子棋落点, 拼接效果：x->x->p->x->x
  92.         :return:四个方向的棋型， List[str]
  93.         """
  94.         def count(x, y): return [p[0] + x, p[1] + y]

  96.         def func(iterator):
  97.             return "".join([self[count(*e)] for e in iterator])
  98.         return [func(v1)[::-1] + self[p] + func(v2) for v1, v2 in VECTOR]

  100.     def get_xy_score(self, spot: Point, flag: str) -> int:
  101.         """
  102.         :param spot:
  103.         :param flag:身份标识
  104.         :return:四个方向的棋型的评分列表
  105.         """
  106.         self[spot] = flag
  107.         chess_type = self._result(spot)
  108.         self[spot] = "0"
  109.         _flag = [COMPUTER, PLAYER][flag == COMPUTER]

  111.         def get(chess):
  112.             for score, rules in ChessType.ScoreRules.items():
  113.                 for rule in rules:
  114.                     if rule.format(flag, _flag) in chess:
  115.                         # TODO 玩家评分修正,玩家活三，单四
  116.                         if flag == PLAYER:
  117.                             if score == ChessType.LIVE_THREE:
  118.                                 score = ChessType.PLAYER_LIVE_THREE
  119.                             if score == ChessType.RUSH_FOUR:
  120.                                 score = ChessType.PLAYER_RUSH_FOUR
  121.                         return score
  122.             return 0.5
  123.         scores = sorted([get(chess) for chess in chess_type], reverse=True)
  124.         return ChessType.score(scores)

  126.     def update_one(self, p: Point) -> Set[Tuple]:
  127.         """
  128.         获取落点周围八个方位总计40个点，排除超出边界的点
  129.         :param p: 落点点
  130.         :return: set[tuple] -> ((x, y),(x1, y1)...)
  131.         """
  132.         self.one_spot.discard(p)
  133.         # TODO 对p点计算位移点。
  134.         def count(x, y): return p[0] + x, p[1] + y
  135.         # TODO 对VECTOR展开，转化一维列表，通过count函数计算位移后的点
  136.         vector = [count(*each) for each in chain.from_iterable(list(chain.from_iterable(VECTOR)))]
  137.         r = set(filter(self.f, vector))
  138.         return r

  140.     def _evaluation(self, computer_scores, player_scores):
  141.         """对相同收益进行比较
  142.             例如对手出现活三，我们有两个点可以堵截，有一个点既能堵截，又能对我们形成收益。
  143.         """
  144.         score, move = player_scores[0]
  145.         moves = []
  146.         for sco, spot in player_scores[:8]:
  147.             if sco == score:
  148.                 moves.append(spot)
  149.         for sco, spot in computer_scores[:8]:
  150.             if spot in moves:
  151.                 return sco, spot
  152.         return False

  154.     def evaluation(self) -> Tuple[int, tuple]:
  155.         """
  156.         对当前棋盘局面进行评估
  157.         :return: Tuple[int, tuple] -> (score, (x, y))
  158.         """
  159.         # TODO 遍历待搜索的着点，对双方进行评分.返回双方评分收益大的一个点
  160.         # TODO 遍历得道电脑和玩家落子最大收益
  161.         computer_scores = [(self.get_xy_score(spot, COMPUTER), spot) for spot in self.one_spot]
  162.         player_scores = [(-self.get_xy_score(spot, PLAYER), spot) for spot in self.one_spot]
  163.         # TODO 排序获得最大收益点
  164.         computer_scores = sorted(computer_scores, key=lambda p: p[0], reverse=True)
  165.         player_scores = sorted(player_scores, key=lambda p: p[0])
  166.         # TODO 如果电脑收益大于玩家,直接返回电脑得分点
  167.         if computer_scores[0][0] > abs(player_scores[0][0]):
  168.             return computer_scores[0]
  169.         # TODO 如果电脑收益小于于玩家,进行收益进行比较
  170.         res = self._evaluation(computer_scores, player_scores)
  171.         if res:
  172.             return res
  173.         # TODO 返回玩家收益点
  174.         return player_scores[0]
复制代码

  1. from CoreCode import GoBangBase
  2. from setting import COMPUTER


  5. class Board(GoBangBase):
  6.     """
  7.     棋盘管理：
  8.         computer_order -->  电脑落子记录
  9.         player_order   -->  电脑落子记录
  10.     Method

  12.     """
  13.     computer_order: list = list()
  14.     player_order: list = list()

  16.     def modify(self, spot: list, identity: str) -> None:
  17.         self[spot] = identity
  18.         self.computer_order.append(spot) if identity == COMPUTER else self.player_order.append(spot)

  20.     @staticmethod
  21.     def game_over():
  22.         return False

  24.     def ai_move(self):
  25.         try:
  26.             result = self.evaluation()
  27.         except IndexError:
  28.             return 0, (8, 8)
  29.         return result
复制代码


  2. # -*- coding: utf-8 -*-
  3. # !/usr/bin/python3
  4. """
  5. @ version: ??
  6. @ author: Alex
  7. @ file: cmd_board
  8. @ datetime: 2021/02/09 - 14:08
  9. @ explain:
  10. """
  11. from CoreCode import Board
  12. from setting import SIZE, COMPUTER, PLAYER
  13. from CoreCode.tools import LogHandler
  14. log = LogHandler("borad", file=True)


  17. class StrBoard(Board):

  19.     yingshe = {
  20.         "0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,
  21.         "9":9,"a":10,"b":11,"c":12,"d":13
  22.     }

  24.     def print_board(self):
  25.         str1 = "0123456789abcde"
  26.         r = ''
  27.         for x in range(SIZE):
  28.             s = ""
  29.             for y in range(SIZE):
  30.                 s += " " + self[(x, y)]
  31.             r += str1[x]+"  " + s + "\n"
  32.         str1 ="x/y " + " ".join(str1)
  33.         print(r + str1)

  35.     def main(self):
  36.         next_move = COMPUTER
  37.         while True:
  38.             self.print_board()
  39.             if next_move == PLAYER:
  40.                 r = input("请输入你要落子的位置(0-d)：0d or 91>>>>")
  41.                 x,y = self.yingshe[r[0]], self.yingshe[r[1]]
  42.                 self[(x, y)] = PLAYER
  43.                 bb = self.update_one((x, y))
  44.                 self.one_spot |= bb
  45.                 next_move = COMPUTER
  46.                 self.player_order.append((x, y))
  47.             else:
  48.                 r = self.ai_move()
  49.                 print(f"运行结果:{r}\n")
  50.                 self[r[1]] = COMPUTER
  51.                 bb = self.update_one(r[1])
  52.                 self.one_spot |= bb
  53.                 next_move = PLAYER
  54.                 self.computer_order.append(r[1])


  57. if __name__ == '__main__':
  58.     s = StrBoard()
  59.     try:
  60.         s.main()
  61.     except KeyError:
  62.         log.warning(f"\n{s.player_order}\n{s.computer_order}\n")
复制代码

  1. # -*- coding: utf-8 -*-
  2. # !/usr/bin/python3
  3. """
  4. @ version: ??
  5. @ author: Alex
  6. @ file: setting
  7. @ datetime: 2020/10/17 - 21:08
  8. @ explain:
  9. """
  10. # TODO 棋盘大小
  11. SIZE = 15

  13. # TODO VECTOR 向量，
  14. f = lambda x, y: '[(0 {} v, 0 {} v) for v in range(1, 6)]'.format(x, y)
  15. VECTOR = [
  16.     # TODO X轴
  17.     [eval(f("-", "*")), eval(f("+", "*"))],
  18.     # TODO Y轴
  19.     [eval(f("*", "+")), eval(f("*", "-"))],
  20.     # TODO 左斜轴
  21.     [eval(f("-", "+")), eval(f("+", "-"))],
  22.     # TODO 右斜轴
  23.     [eval(f("-", "-")), eval(f("+", "+"))],
  24. ]
  25. # TODO 身份标识符，电脑落子代表1 玩家落子代表2
  26. COMPUTER = "1"
  27. PLAYER = "2"
  28. # TODO 分支8，搜索深度 5，博弈树节点
  29. BRANCH = 8
  30. DEPTH = 3


  33. class ChessType:
  34.     """
  35.     (1) 如果有一个方向已经成5连, 其分值记为5000;
  36.     (2) 未出现 (1) , 有一个方向已经成活4, 其分值记为1000;
  37.     (3) 未出现 (1) 、 (2) , 有两个方向出现单4, 其分值记为1000;
  38.     (4) 未出现 (1) 、 (2) 、 (3) , 有两个方向出现单4和活3, 其分值记为998;
  39.     (5) 未出现 (1) 、 (2) 、 (3) 、 (4) , 有两个方向成活3, 其分值记为954;
  40.     (6) 未出现上述情况, 将4个方向中单子分值最大的2个值相加作为其分值。
  41.     己方单4   73
  42.     对方单4   84
  43.     己方活3   67
  44.     对方活3   79
  45.     单3       16
  46.     活2       13
  47.     单2       7
  48.     活1       3
  49.     单1       1
  50.     """
  51.     ScoreRules = {
  52.         # TODO 得分[int]:棋型List[str]
  53.         #  如果有新的棋型，在此添加，范围仅限，单活1-4棋型
  54.         #  TODO  眠一型
  55.         1: ["0{0}{1}", "{1}{0}0"],
  56.         #  TODO  活一型
  57.         3: ["0{0}0"],
  58.         #  TODO  眠二型
  59.         7: ["0{0}{0}{1}", "0{0}0{0}{1}", "0{0}00{0}{1}", "{0}000{0}"],
  60.         #  TODO  活二型
  61.         13: ["0{0}{0}0", "0{0}0{0}0", "{0}00{0}", "0{0}{0}0"],
  62.         #  TODO  眠三型
  63.         16: [
  64.             "0{0}{0}{0}{1}", "{1}{0}{0}{0}0", "0{0}0{0}{0}{1}",
  65.             "{1}{0}0{0}{0}0", "0{0}{0}0{0}{1}", "{1}{0}{0}0{0}0",
  66.             "{1}0{0}{0}{0}0{1}", "{0}00{0}{0}", "{0}0{0}0{0}"
  67.         ],
  68.         #  TODO  活三型
  69.         67: ["0{0}{0}{0}0", "0{0}0{0}{0}0", "0{0}{0}0{0}0"],
  70.         #  TODO  眠四型
  71.         73: ["0{0}{0}{0}{0}{1}", "{0}0{0}{0}{0}", "{0}{0}0{0}{0}", "{0}{0}{0}0{0}", "{1}{0}{0}{0}{0}0"],
  72.         #  TODO  活四型
  73.         1000: ["0{0}{0}{0}{0}0"],
  74.         #  TODO  连五型
  75.         5000: ["{0}{0}{0}{0}{0}"]
  76.     }
  77.     LIVE_THREE: int = 67
  78.     RUSH_FOUR: int = 73
  79.     # TODO 对方活3及单四评分
  80.     PLAYER_LIVE_THREE: int = 79
  81.     PLAYER_RUSH_FOUR: int = 84
  82.     # TODO 异常棋型得分，双活三，单四活三，双单四，
  83.     DOUBLE_LIVE_THREE: int = 954
  84.     RUSH_FOUR_LIVE_THREE: int = 998
  85.     DOUBLE_RUSH_FOUR: int = 1000

  87.     @staticmethod
  88.     def score(scores) -> int:
  89.         """返回最终评分
  90.             如果有新的异常棋型得分，在此修改。
  91.             scores->List[int]是一个落子的四个方向的棋型得分
  92.         """
  93.         value = scores[0] + scores[1]
  94.         # TODO 连五棋型 5000分
  95.         if value >= 5000:
  96.             return 5000
  97.         # TODO 双冲四棋型 1000分
  98.         if value >= ChessType.RUSH_FOUR * 2:
  99.             return ChessType.DOUBLE_RUSH_FOUR
  100.         # TODO 活四+活三棋型 998分
  101.         elif value >= ChessType.RUSH_FOUR + ChessType.LIVE_THREE:
  102.             return ChessType.RUSH_FOUR_LIVE_THREE
  103.         # TODO 双活三棋型 954分
  104.         elif value >= ChessType.LIVE_THREE * 2:
  105.             return ChessType.DOUBLE_LIVE_THREE
  106.         # TODO 以上都不符
  107.         return value
复制代码

评分

参与人数 3荣誉 +13 鱼币 +8 贡献 +6 收起 理由
hrp + 3 + 3
ArouArou + 5 + 5 + 3 厉害了 老哥！
昨非 + 5 + 3 鱼C有你更精彩^_^

查看全部评分

小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

ArouArou
发表于 2021-2-17 08:47:51 | 显示全部楼层
顶楼!
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

hrp
发表于 2021-2-17 09:23:05 From FishC Mobile | 显示全部楼层
学习
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

crisfo
发表于 2021-2-17 10:03:59 | 显示全部楼层
厉害
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-6-27 21:08

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表