Exemple #1
0
	def __init__(self, surface, game):
	
		self.game = game
		self.surface = surface
		
		left = 100
		
		self.boardPos = (left, Cell.size)
		self.boardRect = pygame.Rect(self.boardPos, (Cell.size * 11, Cell.size * 6))
		boardSurf = surface.subsurface(self.boardRect)
		self.boardView = BoardView(boardSurf, self.boardPos, game)
		
		self.actionPos = (left, self.boardPos[1] + Cell.size * 6 + Cell.size / 2)
		self.actionRect = pygame.Rect(self.actionPos, (Cell.size * 11, Cell.size))
		actionSurf = surface.subsurface(self.actionRect);
		self.actionView = ActionView(self.actionPos, actionSurf, game)
		
		self.futurePos = (left + 12 * Cell.size, Cell.size)
		self.futureRect = pygame.Rect(self.futurePos, (Cell.size, Cell.size * 6))
		futureSurf = surface.subsurface(self.futureRect)
		self.futureView = FutureView(self.futurePos, futureSurf, game)
		
		self.gameboard = game.gameboard
		self.player = game.player
		self.font = pygame.font.Font(None,24)
    def __init__(self, **props):
        self.model = Checkers()
        self._root = props['root']
        self.parent = props['parent']
        self.training = props['training']  # If true, game will be played
        # against an evolved GPController
        statusbar = Label(self._root,
                          relief=SUNKEN,
                          font=('Helvetica', 7),
                          anchor=NW)
        statusbar.pack(side='bottom', fill='x')
        self.view = BoardView(self._root,
                              model=self.model,
                              parent=self,
                              statusbar=statusbar,
                              invisible=True)
        if self.training:
            self.view.override_canvas(TrainingCanvas())
            self.fitness = props['fitness']

        self.player_color = BLACK
        self.num_players = 1
        self.set_controllers()
        self._controller1.start_turn()
        self.filename = None
Exemple #3
0
class Gameview(object):

	def __init__(self, surface, game):
	
		self.game = game
		self.surface = surface
		
		left = 100
		
		self.boardPos = (left, Cell.size)
		self.boardRect = pygame.Rect(self.boardPos, (Cell.size * 11, Cell.size * 6))
		boardSurf = surface.subsurface(self.boardRect)
		self.boardView = BoardView(boardSurf, self.boardPos, game)
		
		self.actionPos = (left, self.boardPos[1] + Cell.size * 6 + Cell.size / 2)
		self.actionRect = pygame.Rect(self.actionPos, (Cell.size * 11, Cell.size))
		actionSurf = surface.subsurface(self.actionRect);
		self.actionView = ActionView(self.actionPos, actionSurf, game)
		
		self.futurePos = (left + 12 * Cell.size, Cell.size)
		self.futureRect = pygame.Rect(self.futurePos, (Cell.size, Cell.size * 6))
		futureSurf = surface.subsurface(self.futureRect)
		self.futureView = FutureView(self.futurePos, futureSurf, game)
		
		self.gameboard = game.gameboard
		self.player = game.player
		self.font = pygame.font.Font(None,24)

	def notify(self, vec, event):
		
		if self.actionRect.collidepoint(vec):
			return self.actionView.notify(vec, event)
	
		if self.boardRect.collidepoint(vec):
			return self.boardView.notify(vec, event)
		
		if self.futureRect.collidepoint(vec):
			return self.futureView.notify(vec, event)
		
		return None
		
	def draw(self):
		self.surface.fill(THECOLORS["grey23"])
		self.boardView.draw()
		self.actionView.draw()
		self.futureView.draw()
		
		pygame.display.flip()
 def __init__(self):
   super(GameWindow, self).__init__()
   self.game = Game()
   self.ui = Ui_GameWindow()
   self.ui.setupUi(self)
   layoutHuman = QHBoxLayout(self.ui.humanFrame)
   self.humanBoard = BoardView(self.game.human, True)
   layoutHuman.addWidget(self.humanBoard)
   layoutComputer = QHBoxLayout(self.ui.computerFrame)
   self.computerBoard = BoardView(self.game.computer, False)
   layoutComputer.addWidget(self.computerBoard)
   self.ui.actionNewGame.triggered.connect(self.restart)
   self.ui.actionQuit.triggered.connect(self.close)
   self.ui.startButton.clicked.connect(self.startGame)
   self.humanBoard.message.connect(self.status)
   self.computerBoard.computerMove.connect(self.computerMove)
Exemple #5
0
 def __init__(self):
     super(GameWindow, self).__init__()
     self.game = Game()
     self.ui = Ui_GameWindow()
     self.ui.setupUi(self)
     layoutHuman = QHBoxLayout(self.ui.humanFrame)
     self.humanBoard = BoardView(self.game.human, True)
     layoutHuman.addWidget(self.humanBoard)
     layoutComputer = QHBoxLayout(self.ui.computerFrame)
     self.computerBoard = BoardView(self.game.computer, False)
     layoutComputer.addWidget(self.computerBoard)
     self.ui.actionNewGame.triggered.connect(self.restart)
     self.ui.actionQuit.triggered.connect(self.close)
     self.ui.startButton.clicked.connect(self.startGame)
     self.humanBoard.message.connect(self.status)
     self.computerBoard.computerMove.connect(self.computerMove)
Exemple #6
0
 def __init__(self, **props):
     self.model = Checkers()
     self._root = props['root']
     self.parent = props['parent']
     statusbar = Label(self._root,
                       relief=SUNKEN,
                       font=('Helvetica', 7),
                       anchor=NW)
     statusbar.pack(side='bottom', fill='x')
     self.view = BoardView(self._root,
                           model=self.model,
                           parent=self,
                           statusbar=statusbar)
     self.player_color = BLACK
     self.num_players = 1
     self.set_controllers()
     self.controller1.start_turn()
     self.filename = None
     self.think_time = self.parent.thinkTime.get()
 def __init__(self, **props):
     self.model = Checkers()
     self._root = props['root']
     self.parent = props['parent']
     statusbar = Label(self._root, relief=SUNKEN, font=('Helvetica',7),
                       anchor=NW)
     statusbar.pack(side='bottom', fill='x')
     self.view = BoardView(self._root, model=self.model, parent=self,
                           statusbar=statusbar)
     self.player_color = BLACK
     self.num_players = 1
     self.set_controllers()
     self.controller1.start_turn()
     self.filename = None
     self.think_time = self.parent.thinkTime.get()
    def __init__(self, **props):
        self.model = Checkers()
        self._root = props['root']
        self.parent = props['parent']
        self.training = props['training']   # If true, game will be played
                                            # against an evolved GPController
        statusbar = Label(self._root, relief=SUNKEN, font=('Helvetica',7),
                          anchor=NW)
        statusbar.pack(side='bottom', fill='x')
        self.view = BoardView(self._root, model=self.model, parent=self,
                            statusbar=statusbar, invisible=True)
        if self.training:
            self.view.override_canvas(TrainingCanvas())
            self.fitness = props['fitness']

        self.player_color = BLACK
        self.num_players = 1
        self.set_controllers()
        self._controller1.start_turn()
        self.filename = None
Exemple #9
0
class GameWindow(QMainWindow):
    DELAY = 3000

    def __init__(self):
        super(GameWindow, self).__init__()
        self.game = Game()
        self.ui = Ui_GameWindow()
        self.ui.setupUi(self)
        layoutHuman = QHBoxLayout(self.ui.humanFrame)
        self.humanBoard = BoardView(self.game.human, True)
        layoutHuman.addWidget(self.humanBoard)
        layoutComputer = QHBoxLayout(self.ui.computerFrame)
        self.computerBoard = BoardView(self.game.computer, False)
        layoutComputer.addWidget(self.computerBoard)
        self.ui.actionNewGame.triggered.connect(self.restart)
        self.ui.actionQuit.triggered.connect(self.close)
        self.ui.startButton.clicked.connect(self.startGame)
        self.humanBoard.message.connect(self.status)
        self.computerBoard.computerMove.connect(self.computerMove)

    def restart(self):
        self.game = Game()
        self.humanBoard.setBoard(self.game.getHuman())
        self.computerBoard.setBoard(self.game.getComputer())
        self.ui.startButton.setEnabled(True)

    def startGame(self):
        self.game.setPlacing(False)
        self.ui.startButton.setEnabled(False)

    def computerMove(self):
        if self.game.computerDefeated():
            self.status("HUMAN WINS!!!")
        else:
            self.game.computerMove()
            self.humanBoard.update()
            if self.game.humanDefeated():
                self.status("COMPUTER WINS!!!")

    def status(self, text):
        self.statusBar().showMessage(text, self.DELAY)
Exemple #10
0
class GameWindow(QMainWindow):
  DELAY = 3000
  def __init__(self):
    super(GameWindow, self).__init__()
    self.game = Game()
    self.ui = Ui_GameWindow()
    self.ui.setupUi(self)
    layoutHuman = QHBoxLayout(self.ui.humanFrame)
    self.humanBoard = BoardView(self.game.human, True)
    layoutHuman.addWidget(self.humanBoard)
    layoutComputer = QHBoxLayout(self.ui.computerFrame)
    self.computerBoard = BoardView(self.game.computer, False)
    layoutComputer.addWidget(self.computerBoard)
    self.ui.actionNewGame.triggered.connect(self.restart)
    self.ui.actionQuit.triggered.connect(self.close)
    self.ui.startButton.clicked.connect(self.startGame)
    self.humanBoard.message.connect(self.status)
    self.computerBoard.computerMove.connect(self.computerMove)
  def restart(self):
    self.game = Game()
    self.humanBoard.setBoard(self.game.getHuman())
    self.computerBoard.setBoard(self.game.getComputer())
    self.ui.startButton.setEnabled(True)
  def startGame(self):
    self.game.setPlacing(False)
    self.ui.startButton.setEnabled(False)
  def computerMove(self):
    if self.game.computerDefeated():
      self.status("HUMAN WINS!!!")
    else:
      self.game.computerMove()
      self.humanBoard.update()
      if self.game.humanDefeated():
        self.status("COMPUTER WINS!!!")
  def status(self, text):
    self.statusBar().showMessage(text, self.DELAY)
Exemple #11
0
class GameManager(object):
    def __init__(self, **props):
        self.model = Checkers()
        self._root = props['root']
        self.parent = props['parent']
        statusbar = Label(self._root,
                          relief=SUNKEN,
                          font=('Helvetica', 7),
                          anchor=NW)
        statusbar.pack(side='bottom', fill='x')
        self.view = BoardView(self._root,
                              model=self.model,
                              parent=self,
                              statusbar=statusbar)
        self.player_color = BLACK
        self.num_players = 1
        self.set_controllers()
        self.controller1.start_turn()
        self.filename = None
        self.think_time = self.parent.thinkTime.get()

    def set_controllers(self):
        think_time = self.parent.thinkTime.get()
        if self.num_players == 0:
            self.controller1 = AlphaBetaController(
                model=self.model,
                view=self.view,
                searchtime=think_time,
                end_turn_event=self.turn_finished)
            self.controller2 = AlphaBetaController(
                model=self.model,
                view=self.view,
                searchtime=think_time,
                end_turn_event=self.turn_finished)
        elif self.num_players == 1:
            # assumption here is that Black is the player
            self.controller1 = PlayerController(
                model=self.model,
                view=self.view,
                end_turn_event=self.turn_finished)
            self.controller2 = AlphaBetaController(
                model=self.model,
                view=self.view,
                searchtime=think_time,
                end_turn_event=self.turn_finished)
            # swap controllers if White is selected as the player
            if self.player_color == WHITE:
                self.controller1, self.controller2 = self.controller2, self.controller1
        elif self.num_players == 2:
            self.controller1 = PlayerController(
                model=self.model,
                view=self.view,
                end_turn_event=self.turn_finished)
            self.controller2 = PlayerController(
                model=self.model,
                view=self.view,
                end_turn_event=self.turn_finished)
        self.controller1.set_before_turn_event(
            self.controller2.remove_highlights)
        self.controller2.set_before_turn_event(
            self.controller1.remove_highlights)

    def _stop_updates(self):
        # stop alphabeta threads from making any moves
        self.model.curr_state.ok_to_move = False
        self.controller1.stop_process()
        self.controller2.stop_process()

    def _save_curr_game_if_needed(self):
        if self.view.is_dirty():
            msg = 'Do you want to save your changes'
            if self.filename:
                msg += ' to %s?' % self.filename
            else:
                msg += '?'
            result = askyesnocancel(TITLE, msg)
            if result == True:
                self.save_game()
            return result
        else:
            return False

    def new_game(self):
        self._stop_updates()
        self._save_curr_game_if_needed()
        self.filename = None
        self._root.title('Raven ' + VERSION)
        self.model = Checkers()
        self.player_color = BLACK
        self.view.reset_view(self.model)
        self.think_time = self.parent.thinkTime.get()
        self.set_controllers()
        self.view.update_statusbar()
        self.view.reset_toolbar_buttons()
        self.view.curr_annotation = ''
        self.controller1.start_turn()

    def load_game(self, filename):
        self._stop_updates()
        try:
            saved_game = SavedGame()
            saved_game.read(filename)
            self.model.curr_state.clear()
            self.model.curr_state.to_move = saved_game.to_move
            self.num_players = saved_game.num_players
            squares = self.model.curr_state.squares
            for i in saved_game.black_men:
                squares[squaremap[i]] = BLACK | MAN
            for i in saved_game.black_kings:
                squares[squaremap[i]] = BLACK | KING
            for i in saved_game.white_men:
                squares[squaremap[i]] = WHITE | MAN
            for i in saved_game.white_kings:
                squares[squaremap[i]] = WHITE | KING
            self.model.curr_state.reset_undo()
            self.model.curr_state.redo_list = saved_game.moves
            self.model.curr_state.update_piece_count()
            self.view.reset_view(self.model)
            self.view.serializer.restore(saved_game.description)
            self.view.curr_annotation = self.view.get_annotation()
            self.view.flip_board(saved_game.flip_board)
            self.view.update_statusbar()
            self.parent.set_title_bar_filename(filename)
            self.filename = filename
        except IOError as (err):
            showerror(PROGRAM_TITLE, 'Invalid file. ' + str(err))

    def open_game(self):
        self._stop_updates()
        self._save_curr_game_if_needed()
        f = askopenfilename(filetypes=(('Raven Checkers files', '*.rcf'),
                                       ('All files', '*.*')),
                            initialdir=TRAINING_DIR)
        if not f:
            return
        self.load_game(f)

    def save_game_as(self):
        self._stop_updates()
        filename = asksaveasfilename(filetypes=(('Raven Checkers files',
                                                 '*.rcf'), ('All files',
                                                            '*.*')),
                                     initialdir=TRAINING_DIR,
                                     defaultextension='.rcf')
        if filename == '':
            return
        self._write_file(filename)

    def save_game(self):
        self._stop_updates()
        filename = self.filename
        if not self.filename:
            filename = asksaveasfilename(filetypes=(('Raven Checkers files',
                                                     '*.rcf'), ('All files',
                                                                '*.*')),
                                         initialdir=TRAINING_DIR,
                                         defaultextension='.rcf')
            if filename == '':
                return
        self._write_file(filename)

    def _write_file(self, filename):
        try:
            saved_game = SavedGame()
            # undo moves back to the beginning of play
            undo_steps = 0
            while self.model.curr_state.undo_list:
                undo_steps += 1
                self.model.curr_state.undo_move(None, True, True,
                                                self.view.get_annotation())
            # save the state of the board
            saved_game.to_move = self.model.curr_state.to_move
            saved_game.num_players = self.num_players
            saved_game.black_men = []
            saved_game.black_kings = []
            saved_game.white_men = []
            saved_game.white_kings = []
            for i, sq in enumerate(self.model.curr_state.squares):
                if sq == BLACK | MAN:
                    saved_game.black_men.append(KEY_MAP[i])
                elif sq == BLACK | KING:
                    saved_game.black_kings.append(KEY_MAP[i])
                elif sq == WHITE | MAN:
                    saved_game.white_men.append(KEY_MAP[i])
                elif sq == WHITE | KING:
                    saved_game.white_kings.append(KEY_MAP[i])
            saved_game.description = self.view.serializer.dump()
            saved_game.moves = self.model.curr_state.redo_list
            saved_game.flip_board = self.view.flip_view
            saved_game.write(filename)
            # redo moves forward to the previous state
            for i in range(undo_steps):
                annotation = self.view.get_annotation()
                self.model.curr_state.redo_move(None, annotation)
            # record current filename in title bar
            self.parent.set_title_bar_filename(filename)
            self.filename = filename
        except IOError:
            showerror(PROGRAM_TITLE, 'Could not save file.')

    def turn_finished(self):
        if self.model.curr_state.to_move == BLACK:
            self.controller2.end_turn()  # end White's turn
            self._root.update()
            self.view.update_statusbar()
            self.controller1.start_turn()  # begin Black's turn
        else:
            self.controller1.end_turn()  # end Black's turn
            self._root.update()
            self.view.update_statusbar()
            self.controller2.start_turn()  # begin White's turn
Exemple #12
0
filemenu.add_command(label='Open', command=opencmd)
filemenu.add_command(label='Save As', command=saveascmd)
# color menu creation
colormenu = tk.Menu(menubar)
menubar.add_cascade(menu=colormenu, label="Colors")
colormenu.add_command(label='Player 1 Base',
                      command=lambda: set_color(1, base=True))
colormenu.add_command(label='Player 1 Cell', command=lambda: set_color(1))
colormenu.add_command(label='Player 2 Base',
                      command=lambda: set_color(2, base=True))
colormenu.add_command(label='Player 2 Cell', command=lambda: set_color(2))

# controller and boardview setup
button_frame = tk.Frame(root)
turn_box = tk.Label(button_frame, text='PLAYER 1 TURN', width=15)
bdv = BoardView(root, turn_box)
controller = Controller()
controller.boardview = bdv

#move buttons
move_btns = {}
move_btns['A'] = tk.Button(button_frame,
                           relief='groove',
                           text='acquire',
                           width=8,
                           command=lambda: controller.button_pressed('A'))
root.bind('<a>', lambda e: move_btns['A'].invoke())
move_btns['C'] = tk.Button(button_frame,
                           relief='groove',
                           text='conquer',
                           width=8,
class GameManager(object):
    def __init__(self, **props):
        self.model = Checkers()
        self._root = props['root']
        self.parent = props['parent']
        statusbar = Label(self._root, relief=SUNKEN, font=('Helvetica',7),
                          anchor=NW)
        statusbar.pack(side='bottom', fill='x')
        self.view = BoardView(self._root, model=self.model, parent=self,
                              statusbar=statusbar)
        self.player_color = BLACK
        self.num_players = 1
        self.set_controllers()
        self.controller1.start_turn()
        self.filename = None
        self.think_time = self.parent.thinkTime.get()

    def set_controllers(self):
        think_time = self.parent.thinkTime.get()
        if self.num_players == 0:
            self.controller1 = AlphaBetaController(model=self.model,
                                                   view=self.view,
                                                   searchtime=think_time,
                                                   end_turn_event=self.turn_finished)
            self.controller2 = AlphaBetaController(model=self.model,
                                                   view=self.view,
                                                   searchtime=think_time,
                                                   end_turn_event=self.turn_finished)
        elif self.num_players == 1:
            # assumption here is that Black is the player
            self.controller1 = PlayerController(model=self.model,
                                                view=self.view,
                                                end_turn_event=self.turn_finished)
            self.controller2 = AlphaBetaController(model=self.model,
                                                   view=self.view,
                                                   searchtime=think_time,
                                                   end_turn_event=self.turn_finished)
            # swap controllers if White is selected as the player
            if self.player_color == WHITE:
                self.controller1, self.controller2 = self.controller2, self.controller1
        elif self.num_players == 2:
            self.controller1 = PlayerController(model=self.model,
                                                view=self.view,
                                                end_turn_event=self.turn_finished)
            self.controller2 = PlayerController(model=self.model,
                                                view=self.view,
                                                end_turn_event=self.turn_finished)
        self.controller1.set_before_turn_event(self.controller2.remove_highlights)
        self.controller2.set_before_turn_event(self.controller1.remove_highlights)

    def _stop_updates(self):
        # stop alphabeta threads from making any moves
        self.model.curr_state.ok_to_move = False
        self.controller1.stop_process()
        self.controller2.stop_process()

    def _save_curr_game_if_needed(self):
        if self.view.is_dirty():
            msg = 'Do you want to save your changes'
            if self.filename:
                msg += ' to %s?' % self.filename
            else:
                msg += '?'
            result = askyesnocancel(TITLE, msg)
            if result == True:
                self.save_game()
            return result
        else:
            return False

    def new_game(self):
        self._stop_updates()
        self._save_curr_game_if_needed()
        self.filename = None
        self._root.title('Raven ' + VERSION)
        self.model = Checkers()
        self.player_color = BLACK
        self.view.reset_view(self.model)
        self.think_time = self.parent.thinkTime.get()
        self.set_controllers()
        self.view.update_statusbar()
        self.view.reset_toolbar_buttons()
        self.view.curr_annotation = ''
        self.controller1.start_turn()

    def load_game(self, filename):
        self._stop_updates()
        try:
            saved_game = SavedGame()
            saved_game.read(filename)
            self.model.curr_state.clear()
            self.model.curr_state.to_move = saved_game.to_move
            self.num_players = saved_game.num_players
            squares = self.model.curr_state.squares
            for i in saved_game.black_men:
                squares[squaremap[i]] = BLACK | MAN
            for i in saved_game.black_kings:
                squares[squaremap[i]] = BLACK | KING
            for i in saved_game.white_men:
                squares[squaremap[i]] = WHITE | MAN
            for i in saved_game.white_kings:
                squares[squaremap[i]] = WHITE | KING
            self.model.curr_state.reset_undo()
            self.model.curr_state.redo_list = saved_game.moves
            self.model.curr_state.update_piece_count()
            self.view.reset_view(self.model)
            self.view.serializer.restore(saved_game.description)
            self.view.curr_annotation = self.view.get_annotation()
            self.view.flip_board(saved_game.flip_board)
            self.view.update_statusbar()
            self.parent.set_title_bar_filename(filename)
            self.filename = filename
        except IOError as (err):
            showerror(PROGRAM_TITLE, 'Invalid file. ' + str(err))

    def open_game(self):
        self._stop_updates()
        self._save_curr_game_if_needed()
        f = askopenfilename(filetypes=(('Raven Checkers files','*.rcf'),
                                       ('All files','*.*')),
                            initialdir=TRAINING_DIR)
        if not f:
            return
        self.load_game(f)

    def save_game_as(self):
        self._stop_updates()
        filename = asksaveasfilename(filetypes=(('Raven Checkers files','*.rcf'),
                                                ('All files','*.*')),
                                     initialdir=TRAINING_DIR,
                                     defaultextension='.rcf')
        if filename == '':
            return
        self._write_file(filename)

    def save_game(self):
        self._stop_updates()
        filename = self.filename
        if not self.filename:
            filename = asksaveasfilename(filetypes=(('Raven Checkers files','*.rcf'),
                                                    ('All files','*.*')),
                                         initialdir=TRAINING_DIR,
                                         defaultextension='.rcf')
            if filename == '':
                return
        self._write_file(filename)

    def _write_file(self, filename):
        try:
            saved_game = SavedGame()
            # undo moves back to the beginning of play
            undo_steps = 0
            while self.model.curr_state.undo_list:
                undo_steps += 1
                self.model.curr_state.undo_move(None, True, True,
                                                self.view.get_annotation())
            # save the state of the board
            saved_game.to_move = self.model.curr_state.to_move
            saved_game.num_players = self.num_players
            saved_game.black_men = []
            saved_game.black_kings = []
            saved_game.white_men = []
            saved_game.white_kings = []
            for i, sq in enumerate(self.model.curr_state.squares):
                if sq == BLACK | MAN:
                    saved_game.black_men.append(KEY_MAP[i])
                elif sq == BLACK | KING:
                    saved_game.black_kings.append(KEY_MAP[i])
                elif sq == WHITE | MAN:
                    saved_game.white_men.append(KEY_MAP[i])
                elif sq == WHITE | KING:
                    saved_game.white_kings.append(KEY_MAP[i])
            saved_game.description = self.view.serializer.dump()
            saved_game.moves = self.model.curr_state.redo_list
            saved_game.flip_board = self.view.flip_view
            saved_game.write(filename)
            # redo moves forward to the previous state
            for i in range(undo_steps):
                annotation = self.view.get_annotation()
                self.model.curr_state.redo_move(None, annotation)
            # record current filename in title bar
            self.parent.set_title_bar_filename(filename)
            self.filename = filename
        except IOError:
            showerror(PROGRAM_TITLE, 'Could not save file.')

    def turn_finished(self):
        if self.model.curr_state.to_move == BLACK:
            self.controller2.end_turn()  # end White's turn
            self._root.update()
            self.view.update_statusbar()
            self.controller1.start_turn()  # begin Black's turn
        else:
            self.controller1.end_turn()  # end Black's turn
            self._root.update()
            self.view.update_statusbar()
            self.controller2.start_turn()  # begin White's turn