예제 #1
0
파일: main.py 프로젝트: lqy9860/qy_code
def main():
    # 初始化棋盘
    chessboard = ChessBoard()
    chessboard.initBoard()
    # 初始化引擎类
    engine = Engine(chessboard)
    engine.play()
예제 #2
0
파일: szs_client.py 프로젝트: cty12/bokken
def set_up():
    global cb, sq
    # load the map and set up the chessboard
    cb = ChessBoard("maps/sample.map")
    # the size of a square in px
    # TODO add config
    sq = 80

    # define colors
    red = (255, 0, 0)
    black = (0, 0, 0)
    global cb_color, surface
    global launcher_up, launcher_down, launcher_left, launcher_right, \
        block, farmer, keymaker
    global clock
    cb_color = [red, black]
    surface = pygame.display.set_mode([sq * x for x in cb.size()])
    # load icons here
    launcher_up = pygame.image.load(icons['launcher-up'])
    launcher_down = pygame.image.load(icons['launcher-down'])
    launcher_left = pygame.image.load(icons['launcher-left'])
    launcher_right = pygame.image.load(icons['launcher-right'])
    block = pygame.image.load(icons['block'])
    farmer = pygame.image.load(icons['farmer'])
    keymaker = pygame.image.load(icons['keymaker'])
    clock = pygame.time.Clock()
예제 #3
0
 def it_can_remove_a_piece(self):
     board = ChessBoard()
     field = board.get_field(4, 6)
     type(field.piece) |should| be(Pawn)
     white_pawn = board.get_piece(4, 6)
     field.piece |should| be(None)
     type(white_pawn) |should| be(Pawn)
    def testSkipCells(self):
        board = ChessBoard()
        analyzeRow("r6r", 1, board)
        row = board.getRank(1)

        self.assertEqual(str(row[0]), "ra1")
        self.assertEqual(str(row[7]), "rh1")
예제 #5
0
 def __init__(self):
     """Instantiate object."""
     self.chessboard = ChessBoard()
     self.player_white = ChessPlayer('white')
     self.player_black = ChessPlayer('black')
     self.setup_board()
     self.current_player = self.player_white
     self.moves = 0
     self.move_number = 1
 def testCenterAllMovesBlockedDiff(self):
     board = ChessBoard()
     board.addPieceToBoard("Bishop", 4, 4, "White")
     board.addPieceToBoard("Pawn", 3, 3, "Black")
     board.addPieceToBoard("Pawn", 5, 5, "Black")
     board.addPieceToBoard("Pawn", 3, 5, "Black")
     board.addPieceToBoard("Pawn", 5, 3, "Black")
     moves = board.getSquare(4, 4).getMoveset(board.getRanks())
     self.assertEqual(4, len(moves))
예제 #7
0
    def initUI(self):

        self.button1 = QPushButton("音乐", self)
        self.button1.clicked.connect(self.button1click)
        self.clicknum = 1
        self.button2 = QPushButton("战况", self)
        self.button2.clicked.connect(self.button2click)
        self.button2.move(80, 530)
        self.button1.move(0, 530)
        self.win = 0
        self.fail = 0
        self.step_num = 0

        self.chessboard = ChessBoard()  # 棋盘类

        palette1 = QPalette()  # 设置棋盘背景
        palette1.setBrush(self.backgroundRole(),
                          QtGui.QBrush(QtGui.QPixmap('img/chessboard.jpg')))
        self.setPalette(palette1)
        # self.setStyleSheet("board-image:url(img/chessboard.jpg)")  # 不知道这为什么不行
        self.setCursor(Qt.PointingHandCursor)  # 鼠标变成手指形状
        self.sound_piece = QSound("sound/move.wav")  # 加载落子音效
        self.sound_win = QSound("sound/win.wav")  # 加载胜利音效
        self.sound_defeated = QSound("sound/defeated.wav")  # 加载失败音效

        self.resize(WIDTH, HEIGHT)  # 固定大小 540*540
        self.setMinimumSize(QtCore.QSize(WIDTH, HEIGHT))
        self.setMaximumSize(QtCore.QSize(WIDTH, HEIGHT))

        self.setWindowTitle("五子棋")  # 窗口名称
        self.setWindowIcon(QIcon('img/black.png'))  # 窗口图标

        # self.lb1 = QLabel('            ', self)
        # self.lb1.move(20, 10)

        self.black = QPixmap('img/black.png')
        self.white = QPixmap('img/white.png')

        self.piece_now = BLACK  # 黑棋先行
        self.my_turn = True  # 玩家先行
        self.step = 0  # 步数
        self.x, self.y = 1000, 1000
        self.mouse_point = LaBel(self)  # 将鼠标图片改为棋子
        self.mouse_point.setScaledContents(True)
        # self.mouse_point.setPixmap(self.black)  # 加载黑棋
        self.mouse_point.setGeometry(270, 270, PIECE, PIECE)
        self.pieces = [LaBel(self) for i in range(225)]  # 新建棋子标签,准备在棋盘上绘制棋子
        for piece in self.pieces:
            piece.setVisible(True)  # 图片可视
            piece.setScaledContents(True)  # 图片大小根据标签大小可变

        self.mouse_point.raise_()  # 鼠标始终在最上层
        self.ai_down = True  # AI已下棋,主要是为了加锁,当值是False的时候说明AI正在思考,这时候玩家鼠标点击失效,要忽略掉 mousePressEvent

        self.setMouseTracking(True)
        self.show()
예제 #8
0
 def its_fields_have_colors(self):
     board = ChessBoard()
     corner0 = board.get_field(0, 0)
     corner0.color |should| equal_to("white")
     corner1 = board.get_field(0, 7)
     corner1.color |should| equal_to("black")
     corner2 = board.get_field(7, 0)
     corner2.color |should| equal_to("black")
     corner3 = board.get_field(7, 7)
     corner3.color |should| equal_to("white")
 def testSumFourPiecesBlackCanCastle(self):
     board = ChessBoard()
     board.addPieceToBoard("Pawn", 5, 2, "Black")
     board.addPieceToBoard("Pawn", 4, 2, "Black")
     board.addPieceToBoard("Pawn", 6, 2, "Black")
     board.addPieceToBoard("King", 4, 1, "Black")
     board.blackCanCastle()
     self.assertEqual(board.calculateAllMoves(1), 6)
 def testOppositeNothing(self):
     board = ChessBoard()
     board.addPieceToBoard("Pawn", 5, 2, "Black")
     board.addPieceToBoard("Pawn", 4, 2, "Black")
     board.addPieceToBoard("Pawn", 6, 2, "Black")
     board.addPieceToBoard("King", 5, 1, "Black")
     board.blackCanCastle()
     self.assertEqual(board.calculateAllMoves(0), 0)
 def testSumFourPiecesWhiteCanCastle(self):
     board = ChessBoard()
     board.addPieceToBoard("Pawn", 5, 2, "White")
     board.addPieceToBoard("Pawn", 4, 2, "White")
     board.addPieceToBoard("Pawn", 6, 2, "White")
     board.addPieceToBoard("King", 5, 1, "White")
     board.whiteCanCastle()
     self.assertEqual(board.calculateAllMoves(0), 9)
예제 #12
0
    def test_get_path(self):
        self.b = ChessBoard()

        # check path for a white bishop (C1) -> (E3), blocked by own pawn
        self.assertFalse(self.b._check_path([7, 2], [-1, 1], [5, 4]))

        # move black pawn and later white pawn as well as check path for same knight
        self.b.move('d2', 'd4')
        self.assertTrue(self.b._check_path([7, 2], [-1, 1], [5, 4]))

        # check path for white pawn (C3) -> (C5), no obstacles
        self.assertTrue(self.b._check_path([6, 2], [-1, 0], [4, 2]))
 def testAnalyzeEmptyRow(self):
     board = ChessBoard()
     analyzeRow("8", 1, board)
     row = board.getRank(1)
     self.assertEqual(row[0], 0)
     self.assertEqual(row[1], 0)
     self.assertEqual(row[2], 0)
     self.assertEqual(row[3], 0)
     self.assertEqual(row[4], 0)
     self.assertEqual(row[5], 0)
     self.assertEqual(row[6], 0)
     self.assertEqual(row[7], 0)
예제 #14
0
 def it_can_put_a_piece(self):
     board = ChessBoard()
     origin_field = board.get_field(2, 6)
     target_field = board.get_field(2, 4)
     board.turn |should| equal_to("white")
     type(origin_field.piece) |should| be(Pawn)
     target_field.piece |should| be(None)
     white_pawn = board.get_piece(2, 6)
     board.put_piece(white_pawn, 2, 4)
     board.turn |should| equal_to("black")
     origin_field.piece |should| be(None)
     type(target_field.piece) |should| be(Pawn)
예제 #15
0
 def it_has_pieces(self):
     board = ChessBoard()
     corner0 = board.get_field(0, 0)
     type(corner0.piece) |should| be(Rook)
     corner0.piece.color |should| equal_to("black")
     field = board.get_field(2, 1)
     print field.piece
     type(field.piece) |should| be(Pawn)
     field.piece.color |should| equal_to("black")
     field = board.get_field(2, 6)
     type(field.piece) |should| be(Pawn)
     field.piece.color |should| equal_to("white")
    def testBlackFirstRow(self):
        board = ChessBoard()
        analyzeRow("rnbqkbnr", 1, board)
        row = board.getRank(1)

        self.assertEqual(str(row[0]), "ra1")
        self.assertEqual(str(row[1]), "nb1")
        self.assertEqual(str(row[2]), "bc1")
        self.assertEqual(str(row[3]), "qd1")
        self.assertEqual(str(row[4]), "ke1")
        self.assertEqual(str(row[5]), "bf1")
        self.assertEqual(str(row[6]), "ng1")
        self.assertEqual(str(row[7]), "rh1")
예제 #17
0
파일: main.py 프로젝트: lqy9860/qy_code
def test5():
    # 初始化棋盘
    chessboard = ChessBoard()
    chessboard.initBoard()
    # 初始化棋子类
    chessman = ChessMan()
    chessman.Color = 'o'

    # 初始化引擎类
    engine = Engine(chessboard)

    while 1:
        # 获取用户下棋位置
        userInput = input("请输入用户下棋位置:")

        engine.userGo(chessman, userInput)
        # 放置用户下棋位置
        chessboard.setChessMan(chessman)
        # 打印棋盘
        RET = engine.isWonMan(chessman)
        chessboard.printBoard()

        if RET:
            print('win')
            break
    def initUI(self):

        self.chessboard = ChessBoard()  # 棋盘类
        self.chess_manual = []
        self.Going = False
        palette1 = QPalette()  # 设置棋盘背景
        pix = QtGui.QPixmap('board_' + str(N_LINE) + '.jpg')
        pix = pix.scaled(WIDTH, HEIGHT)
        palette1.setBrush(self.backgroundRole(), QtGui.QBrush(pix))
        self.setPalette(palette1)
        # self.setStyleSheet("board-image:url(img/chessboard.jpg)")# 不知道这为什么不行
        self.setCursor(Qt.PointingHandCursor)  # 鼠标变成手指形状
        #self.sound_piece = QSound("sound/luozi.wav")# 加载落子音效
        # self.sound_win = QSound("sound/win.wav")# 加载胜利音效
        # self.sound_defeated = QSound("sound/defeated.wav")# 加载失败音效

        self.resize(WIDTH, HEIGHT)  # 固定大小 540*540
        self.setMinimumSize(QtCore.QSize(WIDTH, HEIGHT))
        self.setMaximumSize(QtCore.QSize(WIDTH, HEIGHT))

        self.setWindowTitle("GoBang")  # 窗口名称
        # self.setWindowIcon(QIcon('img/black.png'))# 窗口图标

        # self.lb1 = QLabel('			', self)
        # self.lb1.move(20, 10)

        self.black = QPixmap('black.png')
        self.white = QPixmap('white.png')

        self.is_black_do = True  # 黑棋回合先行

        self.step = 0  # 步数
        self.x, self.y = 1000, 1000

        self.mouse_point = LaBel(self)  # 将鼠标图片改为棋子
        self.mouse_point.setScaledContents(True)
        self.mouse_point.setPixmap(self.black)  #加载黑棋
        self.mouse_point.setGeometry(270, 270, PIECE, PIECE)
        self.pieces = [LaBel(self) for i in range(225)]  # 新建棋子标签,准备在棋盘上绘制棋子
        for piece in self.pieces:
            piece.setVisible(True)  # 图片可视
            piece.setScaledContents(True)  #图片大小根据标签大小可变

        self.mouse_point.raise_()  # 鼠标始终在最上层
        #self.ai_down = True# AI已下棋,主要是为了加锁,当值是False的时候说明AI正在思考,这时候玩家鼠标点击失效,要忽略掉 mousePressEvent

        self.setMouseTracking(True)
        self.show()
        self.display_it()
예제 #19
0
def make_move():
    if request.method == 'POST':
        try:
            move_data = request.get_json()
            board = ChessBoard(move_data)
            new_move = board.makeMove()
            for key in new_move:
                src = key
                dest = new_move[key]
            source = board.convertCoord(src[0]) + str(src[1])
            destination = board.convertCoord(dest[0]) + str(dest[1])

            return jsonify(sourceID=source, destID=destination)
        except Exception as err:
            print((err))
예제 #20
0
    def initUI(self):

        self.chessboard = ChessBoard()  # 棋盘类

        palette1 = QPalette()  # 设置棋盘背景
        palette1.setBrush(self.backgroundRole(),
                          QtGui.QBrush(QtGui.QPixmap('img/1.jpg')))
        self.setPalette(palette1)
        # self.setStyleSheet("board-image:url(img/chessboard.jpg)")  # 不知道这为什么不行
        self.setCursor(Qt.PointingHandCursor)  # 鼠标变成手指形状

        self.resize(WIDTH, HEIGHT)  # 固定大小 540*540
        self.setMinimumSize(QtCore.QSize(WIDTH, HEIGHT))
        self.setMaximumSize(QtCore.QSize(WIDTH, HEIGHT))

        self.setWindowTitle("黑白棋")  # 窗口名称
        self.setWindowIcon(QIcon('img/black.png'))  # 窗口图标

        # self.lb1 = QLabel('            ', self)
        # self.lb1.move(20, 10)

        self.black = QPixmap('img/black.png')
        self.white = QPixmap('img/white.png')

        self.piece_now = BLACK  # 黑棋先行
        self.my_turn = True  # 玩家先行
        self.step = 0  # 步数
        self.x, self.y = 1000, 1000

        self.mouse_point = LaBel(self)  # 将鼠标图片改为棋子
        self.mouse_point.setScaledContents(True)
        self.mouse_point.setPixmap(self.black)  # 加载黑棋
        self.mouse_point.setGeometry(270, 270, PIECE, PIECE)
        self.pieces = [LaBel(self) for i in range(4096)]  # 新建棋子标签,准备在棋盘上绘制棋子
        for piece in self.pieces:
            piece.setVisible(True)  # 图片可视
            piece.setScaledContents(True)  # 图片大小根据标签大小可变

        self.mouse_point.raise_()  # 鼠标始终在最上层
        self.ai_down = True  # AI已下棋,主要是为了加锁,当值是False的时候说明AI正在思考,这时候玩家鼠标点击失效,要忽略掉 mousePressEvent

        self.draw(3, 3)
        self.draw(3, 4)
        self.draw(4, 4)
        self.draw(4, 3)

        self.setMouseTracking(True)
        self.show()
예제 #21
0
파일: springaren.py 프로젝트: MaxKrog/KTH
    def __init__(self, root):
        self.root = root

        #Knapparnas-container
        self.menu = Frame(self.root)
        self.menu.pack()

        #Ny-omgång knappen
        self.newGameButton = Button(self.menu,
                                    height=1,
                                    width=20,
                                    text="Ny spelomgång")
        self.newGameButton.bind("<Button-1>", self.newGame)
        self.newGameButton.pack(side=LEFT)

        #highscore-knappen
        self.highscoreButton = Button(self.menu,
                                      height=1,
                                      width=20,
                                      text="Toggla Highscores")
        self.highscoreButton.bind("<Button-1>", self.toggleHighscore)
        self.highscoreButton.pack(side=LEFT)

        #Highscore-vyn
        self.highscoreView = Highscore(self.root, "highscores.txt")
        self.highscoreBool = False

        #Spel-vyn
        self.gameView = ChessBoard(self, self.root)
        self.gameView.container.pack()
예제 #22
0
def initBoard(fileLocation):
    """This method reads a .fen file and returns a board representing its state
    
    Args:
        Complete or partial filepath to .fen file
        
    Returns:
        Board representing contents of file, or None if an error during analysis
    
    """
    board = ChessBoard()

    try:
        infile = open(fileLocation, "r")
    except FileNotFoundError:
        print("File", fileLocation,
              "could not be found, please check your input")
        return

    data = infile.read().split('/')
    if (len(data) != 8):
        print("Input file", fileLocation,
              "did not contain enough ranks, please check your input")
        return
    counter = 8
    for row in data:
        try:
            analyzeRow(row, counter, board)
        except ValueError:
            print("A bad value was in row", counter)
            return
        counter -= 1
    infile.close()
    return board
예제 #23
0
    def __init__(self):
        self.board = ChessBoard()
        self.display = Display(self)
        self.player1 = PolicyPlayer(1, 2, self)
        self.player2 = PolicyPlayer(2, 1, self)

        super(PolicyPKPolicyGame, self).__init__(self.board, self.display,
                                                 self.player1, self.player2)
예제 #24
0
    def __init__(self):
        self.board = ChessBoard()
        self.display = TkinterDisplay(self)
        self.player1 = TkinterHumanPlayer(1, 2, self)
        self.player2 = PolicyPlayer(2, 1, self)

        super(HumanPKPolicyGame, self).__init__(self.board, self.display,
                                                self.player1, self.player2)
예제 #25
0
    def newGame(self, event):
        if self.highscoreBool:
            self.highscoreView.container.pack_forget()
            self.highscoreBool = not self.highscoreBool

        self.gameView.container.pack_forget()
        self.gameView.container.destroy()
        self.gameView = ChessBoard(self, self.root)  #Ny instans av ChessBoard.
        self.gameView.container.pack()
예제 #26
0
def custom_game():
    # 策略玩家自我对弈的动态效果
    board = ChessBoard()
    game = Game(board, None, None, None)
    game.display = TkinterDisplay(game)
    game.player1 = PolicyPlayer(1, 2, game)
    game.player2 = PolicyPlayer(2, 1, game)
    game.player = game.player1
    game.mainloop()
예제 #27
0
    def make_human_move(self, move):
        try:

            if move == None:
                raise Exception

            if not self.move_validator.is_move_valid(
                    self.chessboard.chess_board, move[0], move[1],
                    ChessBoard.WHITE_PAWN):
                raise Exception

            ChessBoard.move_piece(self.chessboard.chess_board, move[0],
                                  move[1])

            self.game_state = GameState.PLAYING

        except:
            self.game_state = GameState.WRONG_MOVE
예제 #28
0
class TestCaseChessBoardMove(unittest.TestCase):
    def setUp(self) -> None:
        self.b = ChessBoard()

    def test_MoveNothingToMove(self):
        with self.assertRaises(CBNothingToMoveE):
            self.b.move('a3', 'a4')
        self.assertEqual(self.b.moves, 0)

    def test_MoveSameColorNoMove(self):
        with self.assertRaises(CBSameColorE):
            self.b.move('a2', 'b2')

    def test_MoveEmptyDestination(self):
        self.assertTrue(self.b.move('a2', 'a4'))

    def tearDown(self) -> None:
        del self.b
예제 #29
0
 def new(self):
     self.turn = ESide.White
     self.currentPiece = None
     self.gameReview = [None, None, None
                        ]  #keeps track of the moves played during the game
     self.bgDraw()
     self.grid = self.getAndDrawGrid(
     )  #The key to transit between coords and the screen
     self.chessboard = ChessBoard()
     self.run()
예제 #30
0
    def initUI(self):

        self.chessboard = ChessBoard()  # 棋盘类

        palette1 = QPalette()  # 设置棋盘背景
        palette1.setBrush(self.backgroundRole(),
                          QtGui.QBrush(QtGui.QPixmap('img/chessboard.jpg')))
        self.setPalette(palette1)
        self.setCursor(Qt.PointingHandCursor)  # 鼠标变成手指形状
        self.sound_piece = QSound("sound/move.wav")  # 加载落子音效
        self.sound_win = QSound("sound/win.wav")  # 加载胜利音效
        self.sound_defeated = QSound("sound/defeated.wav")  # 加载失败音效

        self.resize(WIDTH, HEIGHT)  # 固定大小 540*540
        self.setMinimumSize(QtCore.QSize(WIDTH, HEIGHT))
        self.setMaximumSize(QtCore.QSize(WIDTH, HEIGHT))

        self.setWindowTitle("五子棋")  # 窗口名称
        self.setWindowIcon(QIcon('img/black.png'))  # 窗口图标

        self.black = QPixmap('img/black.png')
        self.white = QPixmap('img/white.png')

        self.piece_now = BLACK  # 黑棋先行
        self.my_turn = True  # 玩家先行
        self.step = 0  # 步数
        self.x, self.y = 1000, 1000

        self.mouse_point = LaBel(self)  # 将鼠标图片改为棋子
        self.mouse_point.setScaledContents(True)
        self.mouse_point.setPixmap(self.black)  # 加载黑棋
        self.mouse_point.setGeometry(270, 270, PIECE, PIECE)
        self.pieces = [LaBel(self) for i in range(225)]  # 新建棋子标签,准备在棋盘上绘制棋子
        for piece in self.pieces:
            piece.setVisible(True)  # 图片可视
            piece.setScaledContents(True)  # 图片大小根据标签大小可变

        self.mouse_point.raise_()  # 鼠标始终在棋盘背景的上方
        self.ai_down = True  # 当ai在执行任务的时候玩家不能使用鼠标

        self.setMouseTracking(True)
        self.show()
예제 #31
0
    def test_coordinate_to_index(self):

        self.assertEqual([7, 0], ChessBoard._coord_to_index('a1'))
        self.assertEqual([6, 0], ChessBoard._coord_to_index('a2'))
        self.assertEqual([7, 0], ChessBoard._coord_to_index('a1'))
        self.assertEqual([7, 0], ChessBoard._coord_to_index('A1'))
        self.assertEqual([0, 7], ChessBoard._coord_to_index('h8'))
        with self.assertRaises(NameError):
            ChessBoard._coord_to_index('g9')
예제 #32
0
 def _simulate_play(self, state):
     board = ChessBoard(self.game.board.width, self.game.board.height,
                        self.game.board.n_in_row, state)
     game = Game(board, None, None, None)
     display = Display(game)
     player1 = PolicyPlayer(self.other_index, self.index, game)
     player2 = PolicyPlayer(self.index, self.other_index, game)
     game.display = display
     game.player = game.player1 = player1
     game.player2 = player2
     game.mainloop()
     return display.win_player is not None and display.win_player.index == self.index
 def testCenterAllMoves(self):
     board = ChessBoard()
     board.addPieceToBoard("Queen", 4, 4, "White")
     moves = board.getSquare(4, 4).getMoveset(board.getRanks())
     self.assertEqual(27, len(moves))
     self.assertIn((4, 3), moves)  #1
     self.assertIn((4, 2), moves)  #2
     self.assertIn((4, 1), moves)  #3
     self.assertIn((4, 5), moves)  #4
     self.assertIn((4, 6), moves)  #5
     self.assertIn((4, 7), moves)  #6
     self.assertIn((4, 8), moves)  #7
     self.assertIn((5, 4), moves)  #8
     self.assertIn((6, 4), moves)  #9
     self.assertIn((7, 4), moves)  #10
     self.assertIn((8, 4), moves)  #11
     self.assertIn((3, 4), moves)  #12
     self.assertIn((2, 4), moves)  #13
     self.assertIn((1, 4), moves)  #14
     self.assertIn((3, 3), moves)  #15
     self.assertIn((2, 2), moves)  #16
     self.assertIn((1, 1), moves)  #17
     self.assertIn((5, 5), moves)  #18
     self.assertIn((6, 6), moves)  #19
     self.assertIn((7, 7), moves)  #20
     self.assertIn((8, 8), moves)  #21
     self.assertIn((5, 3), moves)  #22
     self.assertIn((6, 2), moves)  #23
     self.assertIn((7, 1), moves)  #24
     self.assertIn((3, 5), moves)  #25
     self.assertIn((2, 6), moves)  #26
     self.assertIn((1, 7), moves)  #27
 def testPawnUnblockedFirstSquareBlack(self):
     board = ChessBoard()
     board.addPieceToBoard("Pawn", 4, 7, "Black")
     moves = board.getSquare(4, 7).getMoveset(board.getRanks())
     self.assertEqual(2, len(moves))
     self.assertIn((4, 6), moves)
     self.assertIn((4, 5), moves)     
 def testPawnBlockedDiffColor(self):
     board = ChessBoard()
     board.addPieceToBoard("Pawn", 4, 4, "White")
     board.addPieceToBoard("Pawn", 4, 5, "Black")
     moves = board.getSquare(4, 4).getMoveset(board.getRanks())
     self.assertEqual(0, len(moves))
     self.assertNotIn((4, 5), moves)
예제 #36
0
 def it_only_remove_pieces_of_turn_player(self):
     board = ChessBoard()
     field1 = board.get_field(4, 1)
     type(field1.piece) |should| be(Pawn)
     board.get_piece(4, 1) |should| be(None)
     type(field1.piece) |should| be(Pawn)
     field2 = board.get_field(4, 6)
     type(field2.piece) |should| be(Pawn)
     white_pawn = board.get_piece(4, 6)
     field2.piece |should| be(None)
     type(white_pawn) |should| be(Pawn)
예제 #37
0
 def it_should_return_all_white_pieces(self):
     board = ChessBoard()
     len(board.get_pieces_from_equal_turn()) |should| equal_to(16)
     for piece in board.get_pieces_from_equal_turn():
         piece.color |should| equal_to('white')
예제 #38
0
class ChessGame(object):

    def __init__(self):

        self.chessboard = ChessBoard()

    def start(self, computerstarts = True):
        
        if computerstarts:
            print 'Computer is white. Take this move, bitch!'
            computer_color = 'white'
            
        else:
            print 'Computer is black. Please, make your move, punk!'
            computer_color = 'black'

        if computer_color == 'white':


            self.chessboard.draw()
            print 'Initial zobrist: ' + str(self.chessboard.zobrist_number)

            #print 'Resulting score: ' + str(self.chessboard.evaluate(WHITE))
            #print 'Hash key: ' + str(self.chessboard._hash_code)


            depth_white = 4
            depth_black = 5

            n = 1
            playing_color = WHITE

            while 1:

                if playing_color == WHITE:
                    depth = depth_white
                else:
                    depth = depth_black

                t0 = time.time()
                
#                abscore, principal_variation = negamax.alphabeta(self.chessboard, depth, -INF, INF, playing_color)

                t1 = time.time()
#                print 'alphabeta:    ' + str(t1 - t0) + ' ' + str(abscore)
#                print [each.zobrist_number for each in principal_variation]

#                abmemscore, principal_variation = negamax.alphabetamemory(self.chessboard, depth, -INF, INF, playing_color)
                
                t2 = time.time()
#                print 'alphabetamem: ' + str(t2 - t1) + ' ' + str(abmemscore)
#                print [each.zobrist_number for each in principal_variation]

#                idscore, principal_variation = negamax.iterativedeepeningalphabeta(self.chessboard, depth, playing_color)
                
                t3 = time.time()
#                print 'iterdeep:     ' + str(t3 - t2) + ' ' + str(idscore)
#                print [each.zobrist_number for each in principal_variation]

                idmemscore, principal_variation = negamax.iterativedeepeningalphabetamemory(self.chessboard, depth, playing_color)

                t4 = time.time()

#                print 'iterdeepmem:  ' + str(t4 - t3) + ' ' + str(idmemscore)
#                print [each.zobrist_number for each in principal_variation]

#                mtdfscore, principal_variation = negamax.mtdf(self.chessboard, depth, playing_color)

                t5 = time.time()

#                print 'mtdf:         ' + str(t5 - t4) + ' ' + str(mtdfscore)
#                print [each.zobrist_number for each in principal_variation]

#                idmtdfscore, principal_variation = negamax.iterativedeepeningmtdf(self.chessboard, depth, playing_color)
                
                t6 = time.time()
                
#                print 'idmtdf:       ' + str(t6 - t5) + ' ' + str(idmtdfscore)
#                print [each.zobrist_number for each in principal_variation]


                if len(principal_variation) == 1:
                    if playing_color == WHITE:
                        print 'BLACK WON'
                    else:
                        print 'WHITE WON'
                    break
                    
                print ''
                if playing_color == WHITE:
                    print 'WHITE MOVED, n = ' + str(n)
                else:
                    print 'BLACK MOVED, n = ' + str(n)
                n += 1
                self.chessboard = principal_variation[1]
                self.chessboard.draw()

                print 'Resulting score: ' + str(self.chessboard.evaluate())
                print 'New zobrist number: ' + str(self.chessboard.zobrist_number)
                
                flagline = 'En passant flags: '
                for f in range(8):
                    flagline += str(self.chessboard.en_passant_flag(f))

                flagline += '   Castling flags (wq, wk, bq, bk): ' 
                
                if self.chessboard.castling_queen_side_flag(WHITE):
                    flagline += '1'
                else:
                    flagline += '0'
                
                if self.chessboard.castling_king_side_flag(WHITE):
                    flagline += '1'
                else:
                    flagline += '0'
                   
                if self.chessboard.castling_queen_side_flag(BLACK):
                    flagline += '1'
                else:
                    flagline += '0'

                if self.chessboard.castling_king_side_flag(BLACK):
                    flagline += '1'
                else:
                    flagline += '0'
                    

                print flagline
                
                print ''

                if playing_color == WHITE:
                    playing_color = BLACK
                else:
                    playing_color = WHITE
예제 #39
0
 def it_not_should_is_in_checkmate_in_initial_position(self):
     board = ChessBoard()
     board.check_is_in_checkmate() |should| equal_to(False)
예제 #40
0
    def __init__(self):

        self.chessboard = ChessBoard()
예제 #41
0
 def it_should_return_all_black_pieces(self):
     board = ChessBoard()
     len(board.get_pieces_from_other_turn()) |should| equal_to(16)
     for piece in board.get_pieces_from_other_turn():
         piece.color |should| equal_to('black')
예제 #42
0
 def it_knows_all_possibilities_from_white_pieces(self):
     board = ChessBoard()
     board.get_all_possibilities_from_equal_turn() |should| equal_to(set([(0,4),(1,4),(2,4),(3,4),(4,4),(5,4),(6,4),(7,4),(0,5),(1,5),(2,5),(3,5),(4,5),(5,5),(6,5),(7,5)]))
     board.get_all_possibilities_from_equal_turn() |should_not| include((0,2))
예제 #43
0
 def it_knows_all_possibilities_from_black_pieces(self):
     board = ChessBoard()
     board.get_all_possibilities_from_other_turn() |should| equal_to(set([(0,2),(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(0,3),(1,3),(2,3),(3,3),(4,3),(5,3),(6,3),(7,3)]))
     board.get_all_possibilities_from_other_turn() |should_not| include((0,4))
예제 #44
0
 def it_should_is_in_checkmate(self):
     board = ChessBoard()
     board.board[3][5].piece = Horse('black', 3, 5)
     board.check_is_in_checkmate() |should| equal_to(True)