Python游戏开发之《人机大战象棋》-附完备源码-python教程 ...

笑看天下无敌手  金牌会员 | 4 天前 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 719|帖子 719|积分 2157

本日给各人带来的是人机大战的象棋
中国象棋

首先绘制一下棋盘，看看样子：

黑白经典款
绘制棋盘：
  2. class Board(QLabel):
  4.     '''
  5.     棋盘坐标与屏幕坐标类似，左上角为 (0, 0)，右下角为 (8, 9)
  6.     '''
  8.     BOARD = str(dirpath / u"images/board.png")
  9.     MARK = str(dirpath / u"images/mark.png")
  10.     CHECK = str(dirpath / u"images/check.png")
  11.     FAVICON = str(dirpath / u"images/black_bishop.png")
  13.     IMAGES = {
  14.         Chess.R: str(dirpath / 'images/red_rook.png'),
  15.         Chess.N: str(dirpath / 'images/red_knight.png'),
  16.         Chess.B: str(dirpath / 'images/red_bishop.png'),
  17.         Chess.A: str(dirpath / 'images/red_advisor.png'),
  18.         Chess.K: str(dirpath / 'images/red_king.png'),
  19.         Chess.C: str(dirpath / 'images/red_cannon.png'),
  20.         Chess.P: str(dirpath / 'images/red_pawn.png'),
  21.         Chess.r: str(dirpath / 'images/black_rook.png'),
  22.         Chess.n: str(dirpath / 'images/black_knight.png'),
  23.         Chess.b: str(dirpath / 'images/black_bishop.png'),
  24.         Chess.a: str(dirpath / 'images/black_advisor.png'),
  25.         Chess.k: str(dirpath / 'images/black_king.png'),
  26.         Chess.c: str(dirpath / 'images/black_cannon.png'),
  27.         Chess.p: str(dirpath / 'images/black_pawn.png'),
  28.     }
  30.     ANIMATION_DURATION = 280
  32.     flags = QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowCloseButtonHint
  34.     signal_class = BoardSignal
  36.     def __init__(self, parent=None, callback=None):
  37.         super().__init__(parent=parent)
  39.         self.csize = 60
  40.         self.board_image = QtGui.QPixmap(self.BOARD)
  42.         if parent is None:
  43.             self.setWindowIcon(QtGui.QIcon(self.FAVICON))
  44.             self.setWindowTitle(u"Chinese Chess")
  45.             # self.setWindowFlags(self.flags)
  47.         # https://www.mfitzp.com/tutorials/packaging-pyqt5-pyside2-applications-windows-pyinstaller/
  49.         app = QtWidgets.QApplication.instance()
  50.         if app:
  51.             app.setWindowIcon(QtGui.QIcon(self.FAVICON))
  53.         if os.name == 'nt':
  54.             logger.info("set model id")
  55.             ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
  56.                 f'StevenBaby.Chess.{VERSION}'
  57.             )
  59.         self.setObjectName(u"Board")
  60.         self.setScaledContents(True)
  62.         self.animate = QtCore.QPropertyAnimation(self, b'geometry', self)
  64.         self.resize(self.csize * Chess.W, self.csize * Chess.H)
  66.         for chess, path in self.IMAGES.items():
  67.             self.IMAGES[chess] = QPixmap(path)
  69.         mark = QPixmap(self.MARK)
  71.         # 棋盘起始标记
  72.         self.mark1 = QLabel(self)
  73.         self.mark1.setPixmap(mark)
  74.         self.mark1.setScaledContents(True)
  75.         self.mark1.setVisible(False)
  77.         # 棋盘落子标记
  78.         self.mark2 = QLabel(self)
  79.         self.mark2.setPixmap(mark)
  80.         self.mark2.setScaledContents(True)
  81.         self.mark2.setVisible(False)
  83.         check = QPixmap(self.CHECK)
  84.         # 将军棋子标记
  85.         self.mark3 = QLabel(self)
  86.         self.mark3.setPixmap(check)
  87.         self.mark3.setScaledContents(True)
  88.         self.mark3.setVisible(False)
  90.         self.signal = self.signal_class()
  91.         self.signal.refresh.connect(self.refresh)
  93.         self.labels = mat(zeros((Chess.W, Chess.H,)), dtype=QtWidgets.QLabel)
  94.         self.board = mat(zeros((Chess.W, Chess.H,)), dtype=int)
  96.         self.fpos = None
  97.         self.tpos = None
  98.         self.check = None
  99.         self.reverse = False
  101.         self.update()
  103.         self.callback = callback
  105.     def setBoard(self, board, fpos=None, tpos=None):
  106.         # 设置 棋盘 board，以及该步，的棋子从哪儿 fpos，到哪儿 tpos
  107.         # 由于 该函数可能在多个线程中调用，所以下面触发 signal.refresh
  108.         # QT 会自动将刷新棋盘的重任放到主线程去做
  109.         # 如果直接在非主线程调用 refresh 函数，程序可能莫名其妙的死掉。
  111.         self.board = board
  112.         self.fpos = fpos
  113.         self.tpos = tpos
  114.         self.signal.refresh.emit()
复制代码
这个主要是绘制棋盘和棋盘中棋子移动产生的回调。
绘制棋子：
  2. # coding=utf-8
  3. import numpy as np
  5. from logger import logger
  8. class Chess(object):
  10.     NONE = 0
  12.     RMASK = 16  # 第五位表示红方 比如红車 0b01_0_001
  13.     # 判断棋子是不是黑方只需要 按位与 0b0100000 就可以了
  15.     BMASK = 32  # 第六位表示黑方 比如黑炮 0b10_0_110
  16.     # 判断棋子是不是黑方只需要 按位与 0b100000 就可以了
  18.     RED = RMASK
  19.     BLACK = BMASK
  20.     TMASK = 0b110000  # 棋子颜色掩码，可能的取值为 16 和 32
  21.     CMASK = 0b111  # 棋子掩码
  23.     # 棋子使用 1-7 来表示，二进制就是 0b001 - 0b111
  25.     # INDEX = {
  26.     #     '帥': (0, 0), '仕': (1, 0), '相': (2, 0), '傌': (3, 0), '俥': (4, 0), '炮': (5, 0), '兵': (6, 0),
  27.     #     '將': (0, 1), '士': (1, 1), '象': (2, 1), '馬': (3, 1), '車': (4, 1), '砲': (5, 1), '卒': (6, 1),
  28.     # }
  30.     KING = 1
  31.     ADVISOR = 2
  32.     BISHOP = 3
  33.     KNIGHT = 4
  34.     ROOK = 5
  35.     CANNON = 6
  36.     PAWN = 7
  38.     P = PAWN | RMASK
  39.     R = ROOK | RMASK
  40.     N = KNIGHT | RMASK
  41.     B = BISHOP | RMASK
  42.     A = ADVISOR | RMASK
  43.     C = CANNON | RMASK
  44.     K = KING | RMASK
  46.     p = PAWN | BMASK
  47.     r = ROOK | BMASK
  48.     n = KNIGHT | BMASK
  49.     b = BISHOP | BMASK
  50.     a = ADVISOR | BMASK
  51.     c = CANNON | BMASK
  52.     k = KING | BMASK
  54.     WIDTH = 9
  55.     HEIGHT = 10
  56.     W = WIDTH
  57.     H = HEIGHT
  59.     NAMES = {
  60.         0: ' ',
  61.         P: 'P',
  62.         R: 'R',
  63.         N: 'N',
  64.         B: 'B',
  65.         A: 'A',
  66.         C: 'C',
  67.         K: 'K',
  68.         p: 'p',
  69.         r: 'r',
  70.         n: 'n',
  71.         b: 'b',
  72.         a: 'a',
  73.         c: 'c',
  74.         k: 'k',
  75.     }
  77.     CHESSES = {P, R, N, B, A, C, K, p, r, n, b, a, c, k, }
  79.     @staticmethod
  80.     def invert(chess):
  81.         # 转换棋子颜色
  82.         return (chess & 7) | ((~chess) & 0b110000)
  84.     @staticmethod
  85.     def is_red(chess):
  86.         return chess & Chess.RED
  88.     @staticmethod
  89.     def is_black(chess):
  90.         return chess & Chess.BLACK
  92.     @staticmethod
  93.     def chess(c):
  94.         return c & Chess.CMASK
  96.     @staticmethod
  97.     def color(c):
  98.         return c & Chess.TMASK
  100.     ORIGIN = np.mat(
  101.         np.array(
  102.             [
  103.                 [r, 0, 0, p, 0, 0, P, 0, 0, R],
  104.                 [n, 0, c, 0, 0, 0, 0, C, 0, N],
  105.                 [b, 0, 0, p, 0, 0, P, 0, 0, B],
  106.                 [a, 0, 0, 0, 0, 0, 0, 0, 0, A],
  107.                 [k, 0, 0, p, 0, 0, P, 0, 0, K],
  108.                 [a, 0, 0, 0, 0, 0, 0, 0, 0, A],
  109.                 [b, 0, 0, p, 0, 0, P, 0, 0, B],
  110.                 [n, 0, c, 0, 0, 0, 0, C, 0, N],
  111.                 [r, 0, 0, p, 0, 0, P, 0, 0, R]
  112.             ]
  113.         )
  114.     )
  116.     MOVE = 1
  117.     CAPTURE = 2
  118.     DRAW = 3
  119.     CHECK = 4
  120.     INVALID = 5
  121.     CHECKMATE = 6
  122.     RESIGN = 7
  123.     NEWGAME = 8
  125.     # 以下为引擎专用
  126.     INFO = 9
  127.     POPHASH = 10
  128.     NOBESTMOVE = 11
复制代码
还有其他文件，这里就不一一列举了，

主步调：
  2. # coding=utf-8
  4. import sys
  5. import time
  6. from functools import partial
  7. import threading
  9. import numpy as np
  11. import keyboard
  13. from PySide6 import QtWidgets
  14. from PySide6 import QtCore
  15. from PySide6 import QtGui
  17. from board import BoardFrame
  19. from engine import Engine
  20. from engine import UCCIEngine
  21. from engine import Chess
  22. from engine import dirpath
  23. from engine import logger
  24. from engines import UCCI_ENGINES
  25. from situation import Situation
  27. import audio
  28. import engines
  29. import system
  30. from version import VERSION
  32. from dialogs.settings import SettingsDialog
  33. from dialogs.method import MethodDialog
  34. from toast import Toast
  36. from context import BaseContextMenu
  37. from context import BaseContextMenuMixin
  39. from arrange import ArrangeBoard
  40. from manual import Manual
  41. import qqchess
  44. class GameSignal(QtCore.QObject):
  46.     hint = QtCore.Signal(None)
  47.     undo = QtCore.Signal(None)
  48.     redo = QtCore.Signal(None)
  49.     reset = QtCore.Signal(None)
  50.     debug = QtCore.Signal(None)
  52.     load = QtCore.Signal(None)
  53.     save = QtCore.Signal(None)
  54.     paste = QtCore.Signal(None)
  55.     capture = QtCore.Signal(None)
  56.     connecting = QtCore.Signal(None)
  58.     move = QtCore.Signal(int)
  59.     draw = QtCore.Signal(None)
  60.     resign = QtCore.Signal(None)
  61.     checkmate = QtCore.Signal(None)
  62.     nobestmove = QtCore.Signal(None)
  64.     animate = QtCore.Signal(tuple, tuple)
  65.     settings = QtCore.Signal(None)
  66.     method = QtCore.Signal(None)
  67.     arrange = QtCore.Signal(None)
  68.     thinking = QtCore.Signal(bool)
  69.     reverse = QtCore.Signal(None)
  72. class GameContextMenu(BaseContextMenu):
  74.     items = [
  75.         ('提示', 'Ctrl+H', lambda self: self.signal.hint.emit(), True),
  76.         ('悔棋', 'Ctrl+Z', lambda self: self.signal.undo.emit(), True),
  77.         ('重走', 'Ctrl+Shift+Z', lambda self: self.signal.redo.emit(), True),
  78.         'separator',
  79.         ('重置', 'Ctrl+N', lambda self: self.signal.reset.emit(), False),
  80.         ('布局', 'Ctrl+A', lambda self: self.signal.arrange.emit(), True),
  81.         ('着法', 'Ctrl+M', lambda self: self.signal.method.emit(), False),
  82.         ('反转', 'Ctrl+I', lambda self: self.signal.reverse.emit(), False),
  83.         'separator',
  84.         ('粘贴', 'Ctrl+V', lambda self: self.signal.paste.emit(), True),
  85.         ('载入', 'Ctrl+O', lambda self: self.signal.load.emit(), True),
  86.         ('保存', 'Ctrl+S', lambda self: self.signal.save.emit(), True),
  87.         ('截屏', 'Ctrl+K', lambda self: self.signal.capture.emit(), True),
  88.         ('连线', 'Ctrl+L', lambda self: self.signal.connecting.emit(), True),
  89.         'separator',
  90.         ('设置', 'Ctrl+,', lambda self: self.signal.settings.emit(), False),
  91.     ]
  93.     if system.DEBUG:
  94.         items.extend(
  95.             [
  96.                 ('调试', 'Ctrl+D', lambda self: self.signal.debug.emit(), False),
  97.                 'separator',
  98.             ]
  99.         )
  102. class Game(BoardFrame, BaseContextMenuMixin):
  104.     def __init__(self, parent=None):
  105.         super().__init__(parent, board_class=ArrangeBoard)
  106.         self.setWindowTitle(f"中国象棋 v{VERSION}")
  107.         self.setupContextMenu()
  109.         audio.init()
  111.         self.image = None
  113.         self.engine = None
  114.         self.engines = {
  115.             Chess.RED: None,
  116.             Chess.BLACK: None,
  117.         }
  119.         self.engine_side = [Chess.BLACK]
  120.         self.human_side = [Chess.RED]
  122.         self.board.csize = 80
  123.         self.board.callback = self.board_callback
  124.         self.resize(self.board.csize * Chess.W, self.board.csize * Chess.H)
  126.         self.game_signal = GameSignal()
  128.         self.method = MethodDialog(self)
  129.         self.method.setWindowIcon(QtGui.QIcon(self.board.FAVICON))
  131.         self.settings = SettingsDialog(self)
  132.         self.settings.setWindowIcon(QtGui.QIcon(self.board.FAVICON))
  134.         self.game_menu = GameContextMenu(self, self.game_signal)
  136.         self.toast = Toast(self)
  138.         # 以下初始化信号
  140.         keyboard.add_hotkey(
  141.             'ctrl+alt+z', lambda: self.game_signal.capture.emit())
  142.         keyboard.add_hotkey(
  143.             'ctrl+alt+x', lambda: self.game_signal.hint.emit())
  144.         keyboard.add_hotkey(
  145.             'ctrl+alt+m', lambda: self.game_signal.method.emit())
  146.         keyboard.add_hotkey(
  147.             'ctrl+alt+l', lambda: self.game_signal.connecting.emit())
  149.         self.game_signal.reverse.connect(self.reverse)
  150.         self.game_signal.thinking.connect(self.set_thinking)
  151.         self.game_signal.settings.connect(self.settings.show)
  152.         self.game_signal.hint.connect(self.hint)
  153.         self.game_signal.undo.connect(self.undo)
  154.         self.game_signal.redo.connect(self.redo)
  155.         self.game_signal.reset.connect(self.reset)
  156.         self.game_signal.debug.connect(self.debug)
  158.         self.game_signal.load.connect(self.load)
  159.         self.game_signal.save.connect(self.save)
  160.         self.game_signal.paste.connect(self.paste)
  161.         self.game_signal.capture.connect(self.capture)
  163.         self.game_signal.move.connect(self.play)
  165.         self.game_signal.checkmate.connect(self.checkmateMessage)
  166.         self.game_signal.checkmate.connect(lambda: self.set_thinking(False))
  168.         self.game_signal.nobestmove.connect(self.nobestmove)
  170.         self.game_signal.draw.connect(lambda: self.toast.message('和棋！！！'))
  171.         self.game_signal.resign.connect(lambda: self.toast.message('认输了！！！'))
  173.         self.game_signal.animate.connect(self.animate)
  175.         self.settings.transprancy.valueChanged.connect(
  176.             lambda e: self.setWindowOpacity((100 - e) / 100)
  177.         )
  179.         self.settings.reverse.stateChanged.connect(
  180.             lambda e: self.board.setReverse(self.settings.reverse.isChecked())
  181.         )
  183.         self.settings.audio.stateChanged.connect(
  184.             lambda e: audio.play(Chess.MOVE) if e else None
  185.         )
  187.         self.settings.standard_method.stateChanged.connect(
  188.             lambda e: self.method.set_standard(e)
  189.         )
  191.         self.settings.ontop.clicked.connect(self.set_on_top)
  193.         self.settings.ok.clicked.connect(self.accepted)
  194.         self.settings.loads()
  196.         self.game_signal.arrange.connect(self.arrange)
  197.         self.board.signal.finish.connect(self.finish_arrange)
  199.         self.game_signal.method.connect(
  200.             lambda: self.method.setVisible(
  201.                 not self.method.isVisible()))
  202.         self.method.list.currentItemChanged.connect(self.method_changed)
  204.         self.game_signal.connecting.connect(self.connecting)
  205.         # self.qqboard = qqchess.Capturer(self)
  206.         # logger.info("set qqboard %s", self.settings.qqboard)
  207.         # self.qqboard.setGeometry(*self.settings.qqboard)
  208.         # self.qqboard.signal.capture.connect(self.capture_image)
  210.         self.reset()
  211.         self.accepted()
  212.         self.check_openfile()
  214.     def set_on_top(self):
  215.         logger.info("set on top")
  216.         # self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
  218.     def check_openfile(self):
  219.         # 直接打开棋谱文件
  220.         if len(sys.argv) > 1:
  221.             with open(sys.argv[1], encoding='utf8') as file:
  222.                 content = file.read()
  223.             self.pasre_content(content)
  225.     def show_context_menu(self, point):
  226.         if self.board.arranging:
  227.             return self.board.arrange_menu.exec_(self.mapToGlobal(point))
  228.         self.game_menu.exec(self.mapToGlobal(point))
  230.     def update_action_state(self):
  231.         if len(self.engine_side) == 2 and not self.engine.checkmate:
  232.             self.game_menu.setAllMenuEnabled(False)
  233.             self.game_menu.setAllShortcutEnabled(False)
  234.         elif self.thinking:
  235.             self.game_menu.setAllMenuEnabled(False)
  236.             self.game_menu.setAllShortcutEnabled(False)
  237.         else:
  238.             self.game_menu.setAllMenuEnabled(True)
  239.             self.game_menu.setAllShortcutEnabled(True)
  241.     def set_thinking(self, thinking):
  242.         self.thinking = thinking
  243.         logger.debug("set thinking %s", self.thinking)
  244.         if len(self.engine_side) == 2 and not self.engine.checkmate:
  245.             QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.BusyCursor)
  246.         elif self.thinking:
  247.             QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.BusyCursor)
  248.         else:
  249.             QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.ArrowCursor)
  250.         self.update_action_state()
  252.     def arrange(self):
  253.         self.board.arranging = True
  254.         self.board.setBoard(self.board.board)
  255.         self.board.setCheck(None)
  256.         self.game_menu.setAllShortcutEnabled(False)
  258.     def finish_arrange(self, finished):
  259.         if not finished:
  260.             return
  261.         logger.debug('finish arrange')
  262.         self.engine.close()
  263.         self.engine = Engine()
  265.         self.engine.sit.board = self.board.board
  266.         self.engine.sit.turn = self.board.first_side
  267.         self.engine.sit.fen = self.engine.sit.format_current_fen()
  268.         self.try_engine_move()
  269.         self.game_menu.setAllShortcutEnabled(True)
  271.     def method_changed(self, item: QtWidgets.QListWidgetItem):
  272.         index = self.method.list.indexFromItem(item).row()
  273.         self.engine.set_index(index)
  274.         if self.board.animate.state() == QtCore.QAbstractAnimation.State.Running:
  275.             return
  276.         self.updateBoard()
  278.     def accepted(self):
  279.         logger.info("setting accepted....")
  281.         # 设置棋手或AI
  282.         self.engine_side = []
  283.         self.human_side = []
  285.         if self.settings.redside.currentIndex() == 0:
  286.             self.human_side.append(Chess.RED)
  287.         else:
  288.             self.engine_side.append(Chess.RED)
  290.         if self.settings.blackside.currentIndex() == 0:
  291.             self.engine_side.append(Chess.BLACK)
  292.         else:
  293.             self.human_side.append(Chess.BLACK)
  295.         idx = self.settings.red_engine.currentIndex()
  296.         engine = self.engines[Chess.RED]
  297.         if not isinstance(engine, UCCI_ENGINES[idx]):
  298.             self.init_engines(Chess.RED)
  300.         idx = self.settings.black_engine.currentIndex()
  301.         engine = self.engines[Chess.BLACK]
  302.         if not isinstance(engine, UCCI_ENGINES[idx]):
  303.             self.init_engines(Chess.BLACK)
  305.         if len(self.engine_side) == 2:
  306.             self.method.list.setEnabled(False)
  307.         else:
  308.             self.method.list.setEnabled(True)
  309.         self.update_action_state()
  311.         self.try_engine_move()
  313.     def try_engine_move(self):
  314.         if self.engine.sit.turn not in self.engine_side:
  315.             return
  316.         self.go()
  318.     def go(self):
  319.         if self.engine.checkmate:
  320.             self.game_signal.checkmate.emit()
  321.             logger.debug('engine is checkmated hint ignored...')
  322.             return
  323.         self.game_signal.thinking.emit(True)
  324.         engine = self.current_engine()
  325.         engine.position(self.engine.sit.format_fen())
  327.         params = self.settings.get_params(self.engine.sit.turn)
  328.         engine.go(**params)
  330.     def nobestmove(self):
  331.         if self.engine.sit.turn == Chess.RED:
  332.             side = '黑方'
  333.         else:
  334.             side = '红方'
  335.         logger.debug('nobestmove')
  336.         self.toast.message(f"{side}行棋违例！")
  338.     @QtCore.Slot(int)
  339.     def play(self, audio_type):
  340.         if not self.settings.audio.isChecked():
  341.             return
  342.         audio.play(audio_type)
  344.     def init_engines(self, turn=None):
  345.         turns = []
  346.         if turn == Chess.RED:
  347.             turns = [Chess.RED]
  348.         elif turn == Chess.BLACK:
  349.             turns = [Chess.BLACK]
  350.         else:
  351.             turns = [Chess.RED, Chess.BLACK]
  352.         for turn in turns:
  353.             old = self.engines[turn]
  354.             if old:
  355.                 old.close()
  356.             idx = self.settings.get_engine_box(turn).currentIndex()
  357.             new = UCCI_ENGINES[idx](callback=self.engine_callback)
  358.             new.start()
  359.             self.engines[turn] = new
  361.     def current_engine(self) -> Engine:
  362.         return self.engines[self.engine.sit.turn]
  364.     def reverse(self):
  365.         logger.debug("reverse")
  366.         check = self.settings.reverse.isChecked()
  367.         self.settings.reverse.setChecked(not check)
  368.         self.settings.save()
  370.     def reset(self):
  371.         self.init_engines()
  373.         self.engine = Engine()
  375.         self.connected = False
  376.         self.connect_inited = False
  378.         self.fpos = None
  379.         self.board.arranging = False
  380.         self.thinking = False
  381.         self.game_signal.move.emit(Chess.NEWGAME)
  383.         self.updateBoard()
  384.         self.board.setCheck(None)
  385.         self.try_engine_move()
  387.         self.method.refresh(self.engine)
  389.     @QtCore.Slot(None)
  390.     def undo(self):
  391.         for _ in range(2):
  392.             self.engine.undo()
  393.             if self.engine.sit.turn in self.human_side:
  394.                 break
  396.         self.updateBoard()
  398.     @QtCore.Slot(None)
  399.     def redo(self):
  400.         for _ in range(2):
  401.             self.engine.redo()
  402.             logger.debug('engine redo result %d', self.engine.sit.result)
  403.             self.game_signal.move.emit(self.engine.sit.result)
  404.             if self.engine.checkmate:
  405.                 self.game_signal.checkmate.emit()
  406.             if self.engine.sit.turn in self.human_side:
  407.                 break
  409.         self.updateBoard()
  411.     @QtCore.Slot(bool)
  412.     def hint(self):
  413.         if self.thinking:
  414.             logger.debug('engine is thinking hint ignored...')
  415.             return
  416.         self.go()
  418.     @QtCore.Slot(None)
  419.     def debug(self):
  420.         logger.debug("debug slot.....")
  421.         qqchess.show(self.image)
  422.         # logger.debug(self.engine.sit.format_fen())
  424.     @QtCore.Slot(None)
  425.     def save(self):
  426.         dialog = QtWidgets.QFileDialog(self)
  427.         dialog.setFileMode(QtWidgets.QFileDialog.AnyFile)
  428.         filename = dialog.getSaveFileName(
  429.             self, "保存中国象棋文件 Fen", ".", "文件 (*.fen)")[0]
  430.         if not filename:
  431.             return
  432.         fen = self.engine.sit.format_fen()
  433.         with open(filename, 'w', encoding='utf8') as file:
  434.             file.write('fen ')
  435.             file.write(fen)
  436.         logger.info("save file %s - fen %s", filename, fen)
  438.     def pasre_content(self, content: str):
  439.         if not content.startswith('fen '):
  440.             manual = Manual()
  441.             try:
  442.                 manual.callback = lambda fpos, tpos: self.board.setBoard(
  443.                     manual.sit.board,
  444.                     manual.sit.fpos,
  445.                     manual.sit.tpos
  446.                 )
  447.                 manual.parse(content)
  448.             except Exception as e:
  449.                 self.toast.message(str(e))
  450.                 return
  451.             fen = manual.sit.format_fen()
  452.         else:
  453.             fen = content[4:]
  455.         self.engine.index = 0
  456.         self.engine.stack = self.engine.stack[:1]
  457.         self.engine.sit = self.engine.stack[0]
  458.         self.updateBoard()
  459.         self.board.setCheck(None)
  461.         if self.engine.sit.parse_fen(fen, load=True):
  462.             moves = self.engine.sit.moves
  463.             self.engine.sit.moves = []
  464.             for fpos, tpos in moves:
  465.                 result = self.engine.move(fpos, tpos)
  466.                 if result == Chess.CHECKMATE:
  467.                     self.game_signal.checkmate.emit()
  468.                     break
  469.             self.updateBoard()
  470.         else:
  471.             self.toast.message("加载棋谱失败")
  473.     @QtCore.Slot(None)
  474.     def load(self):
  475.         dialog = QtWidgets.QFileDialog(self)
  476.         dialog.setFileMode(QtWidgets.QFileDialog.AnyFile)
  477.         filename = dialog.getOpenFileName(
  478.             self, "打开中国象棋文件 Fen", ".", "fen 文件 (*.fen);;txt 文件 (*.txt)")[0]
  479.         if not filename:
  480.             return
  481.         with open(filename, 'r', encoding='utf8') as file:
  482.             content = file.read()
  483.         self.pasre_content(content)
  485.     def paste(self):
  486.         content = QtWidgets.QApplication.clipboard().text()
  487.         logger.debug('Clipboard text %s', content)
  488.         if content:
  489.             self.pasre_content(content)
  490.             return
  492.         image = qqchess.ImageGrab.grabclipboard()
  493.         if isinstance(image, qqchess.Image.Image):
  494.             self.paste_image(image)
  496.     def capture(self):
  497.         logger.debug("capture...")
  498.         colors = {0: Chess.RMASK, 1: Chess.BMASK}
  499.         board = np.zeros((9, 10), dtype=np.int8)
  500.         while True:
  501.             pred = qqchess.classifier.get_board()
  502.             board0 = board
  503.             board = np.zeros((9, 10), dtype=np.int8)
  504.             for loc, idx in pred.items():
  505.                 board[loc] = (idx[0] + 1) | colors[idx[1]]
  506.             if np.all(board0 == board):
  507.                 break
  509.         # 验证数量
  510.         C = Chess
  511.         wheres = np.argwhere((board == C.K) | (board == C.k))
  512.         if len(wheres) != 2:
  513.             logger.warning("bishop count error %s...", len(wheres))
  514.             return None
  516.         for where in wheres:
  517.             if where[0] < 3 or where[0] > 5:
  518.                 logger.warning("king location error %s...", where)
  519.                 return None
  520.             if 2 < where[1] < 7:
  521.                 logger.warning("king location error %s...", where)
  522.                 return None
  524.         counts = {
  525.             C.P: 5,
  526.             C.R: 2,
  527.             C.N: 2,
  528.             C.B: 2,
  529.             C.A: 2,
  530.             C.C: 2,
  531.             C.p: 5,
  532.             C.r: 2,
  533.             C.n: 2,
  534.             C.b: 2,
  535.             C.a: 2,
  536.             C.c: 2,
  537.         }
  539.         for key, count in counts.items():
  540.             wheres = np.argwhere(board == key)
  541.             if len(wheres) > count:
  542.                 logger.warning("chess count error %s > %s...", len(wheres), count)
  543.                 return None
  545.         wheres = np.argwhere((board == C.B) | (board == C.B))
  546.         for where in wheres:
  547.             if tuple(where) not in {
  548.                 (2, 0), (6, 0),
  549.                 (0, 2), (4, 2), (8, 2),
  550.                 (2, 4), (6, 4),
  551.                 (2, 5), (6, 5),
  552.                 (0, 7), (4, 7), (8, 7),
  553.                 (2, 9), (6, 9),
  554.             }:
  555.                 logger.warning("bishop location error %s...", where)
  556.                 return None
  558.         wheres = np.argwhere((board == C.A) | (board == C.a))
  559.         for where in wheres:
  560.             if tuple(where) not in {
  561.                 (3, 0), (5, 0),
  562.                 (4, 1),
  563.                 (3, 2), (5, 2),
  564.                 (3, 7), (5, 7),
  565.                 (4, 8),
  566.                 (3, 9), (5, 9),
  567.             }:
  568.                 logger.warning("advisor location error %s...", where)
  569.                 return None
  571.         wheres = np.argwhere(board == Chess.K)
  573.         turn = Chess.RED
  574.         self.settings.reverse.setChecked(False)
  575.         if wheres[0][1] < 3:
  576.             logger.debug("reversed")
  577.             board = board[::-1, ::-1]
  578.             self.settings.reverse.setChecked(True)
  579.             turn = Chess.BLACK
  581.         if turn == Chess.RED and self.settings.redside.currentIndex() != 1:
  582.             self.settings.redside.setCurrentIndex(1)
  583.             self.settings.blackside.setCurrentIndex(1)
  584.             self.accepted()
  585.         if turn == Chess.BLACK and self.settings.redside.currentIndex() != 0:
  586.             self.settings.redside.setCurrentIndex(0)
  587.             self.settings.blackside.setCurrentIndex(0)
  588.             self.accepted()
  590.         wheres = np.argwhere((board - self.engine.sit.board) != 0)
  591.         # logger.debug("wheres %s", wheres)
  592.         if len(wheres) == 0:
  593.             return
  595.         if len(wheres) == 2:
  596.             pos1 = tuple(wheres[0])
  597.             pos2 = tuple(wheres[1])
  598.             if board[pos1] != 0 and board[pos2] != 0:
  599.                 return
  601.             assert (board[pos1] == 0 or board[pos2] == 0)
  602.             assert (board[pos1] != 0 or board[pos2] != 0)
  603.             if board[pos1] == 0:
  604.                 fpos = pos1
  605.                 tpos = pos2
  606.             else:
  607.                 fpos = pos2
  608.                 tpos = pos1
  609.             if Chess.color(board[tpos]) != turn:
  610.                 self.move(fpos, tpos)
  611.         elif not self.connect_inited:
  612.             logger.info("reset engine situation")
  613.             # self.engine.close()
  614.             # self.engine = Engine()
  615.             self.engine.index = 0
  616.             self.engine.sit = Situation(board, turn=turn)
  617.             self.engine.stack = [self.engine.sit]
  618.             self.fpos = None
  620.             self.updateBoard()
  621.             self.try_engine_move()
  622.             self.connect_inited = True
  624.     @QtCore.Slot(tuple, tuple)
  625.     def animate(self, fpos, tpos):
  626.         self.board.move(
  627.             self.engine.sit.board, fpos, tpos,
  628.             self.updateBoard,
  629.             self.settings.ui.animate.isChecked(),
  630.         )
  632.     def move(self, fpos, tpos):
  633.         self.game_signal.thinking.emit(False)
  634.         if self.engine.checkmate:
  635.             self.game_signal.checkmate.emit()
  636.             return
  638.         result = self.engine.move(fpos, tpos)
  639.         logger.debug('move result %s', result)
  640.         if not result:
  641.             return
  643.         if result != Chess.INVALID:
  644.             self.game_signal.animate.emit(fpos, tpos)
  645.         else:
  646.             return
  648.         if self.engine.sit.check:
  649.             self.board.setCheck(self.engine.sit.check)
  650.             logger.debug('check ... %s', self.engine.sit.check)
  651.         else:
  652.             self.board.setCheck(None)
  654.         self.game_signal.move.emit(result)
  656.         if result == Chess.CHECKMATE:
  657.             logger.debug("emit checkmate")
  658.             self.game_signal.checkmate.emit()
  659.             return
  661.         self.try_engine_move()
  663.     @QtCore.Slot(int)
  664.     def change_difficulty(self, diff):
  665.         self.depth_computer = diff
  667.     def updateBoard(self):
  668.         if hasattr(self, 'method'):
  669.             self.method.signal.refresh.emit()
  670.         self.board.setBoard(
  671.             self.engine.sit.board,
  672.             self.engine.sit.fpos,
  673.             self.engine.sit.tpos
  674.         )
  676.     @QtCore.Slot(None)
  677.     def checkmateMessage(self):
  678.         if not self.engine.checkmate:
  679.             return
  680.         self.connected = False
  681.         self.connect_inited = False
  683.         if self.engine.sit.turn == Chess.RED:
  684.             self.toast.message("黑方胜!!!")
  685.             # QtWidgets.QMessageBox(self).warning(self, '信息', '')
  686.         else:
  687.             self.toast.message("红方胜!!!")
  688.             # QtWidgets.QMessageBox(self).information(self, '信息', '红方胜!!!')
  690.     def engine_callback(self, type, data):
  691.         if type == Chess.MOVE:
  692.             time.sleep(self.settings.delay.value() / 1000)
  693.             self.move(data[0], data[1])
  694.         elif type == Chess.INFO:
  695.             logger.debug(data)
  696.         elif type == Chess.POPHASH:
  697.             logger.debug(data)
  698.         elif type == Chess.DRAW:
  699.             self.game_signal.draw.emit()
  700.         elif type == Chess.RESIGN:
  701.             self.game_signal.resign.emit()
  702.         elif type == Chess.CHECKMATE:
  703.             pass
  704.             # self.game_signal.checkmate.emit()
  705.         elif type == Chess.NOBESTMOVE:
  706.             self.game_signal.nobestmove.emit()
  708.     def board_callback(self, pos):
  709.         if self.engine.sit.where_turn(pos) == self.engine.sit.turn:
  710.             self.fpos = pos
  711.             self.board.setBoard(self.engine.sit.board, self.fpos)
  712.             return
  714.         if not self.fpos:
  715.             return
  717.         self.move(self.fpos, pos)
  719.     def closeEvent(self, event):
  720.         self.engine.close()
  721.         return super().closeEvent(event)
  723.     def connecting(self):
  724.         self.connected = not self.connected
  725.         if not self.connected:
  726.             if hasattr(self, 'connect_task'):
  727.                 self.connect_task.join()
  728.             return
  730.         def task():
  731.             while self.connected:
  732.                 self.game_signal.capture.emit()
  733.                 logger.debug('connecting... task')
  734.                 time.sleep(2)
  736.         self.connect_task = threading.Thread(target=task, daemon=True)
  737.         self.connect_task.start()
  740. def main():
  741.     app = QtWidgets.QApplication(sys.argv)
  743.     # import qt_material as material
  744.     # extra = {
  745.     #     'font_family': "dengxian SumHei"
  746.     # }
  747.     # material.apply_stylesheet(app, theme='light_blue.xml', invert_secondary=True, extra=extra)
  749.     window = Game()
  750.     window.show()
  751.     sys.exit(app.exec())
  754. if __name__ == '__main__':
  755.     main()
复制代码
运行后：

必要游戏素材，和完备代码，wx扫描下方二维码获取，长期有效大概点击公众号获取。

本文源码转自 https://mp.weixin.qq.com/s/8TY8w6Pd13EI9fPdF8ncAw，如有侵权，请接洽删除。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

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

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

笑看天下无敌手

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表