def chooseMove(self, turn):
ASCIIDisplay.prompt_for_move(turn, self.playerName, self.pieceMarker)
selectMove = KeyboardConsoleInput.read_move()
ASCIIDisplay.newlines()
return selectMove
def makeMove(self,number, playerPiece, player):
if number < 1 or number > self.cols:
ASCIIDisplay.invalid_move_outsideBoard()
return False
for i in range(0, self.rows):
if self.cells[i][number - 1].piece.disp == " " and i == self.rows - 1: # Bottom of the board.
self.cells[i][number - 1].piece.disp = playerPiece
# pop the piece from playerpieces.
# check winner function.
self.checkWinner(i, number - 1, playerPiece, player)
return True # valid move.
if (self.cells[i][number - 1].piece.disp == "R" or self.cells[i][number - 1].piece.disp == "B") and i == 0: # Top of the board.
ASCIIDisplay.invalid_move_coloumn_full(number)
return False # Invalid move.
if self.cells[i][number - 1].piece.disp == "R" or self.cells[i][number - 1].piece.disp == "B": # Midde of board.
self.cells[i - 1][number - 1].piece.disp = playerPiece
# check winner function.
self.checkWinner(i - 1, number - 1, playerPiece, player)
return True # valid move.
def read_move(col):
while True:
try:
move = int(input())
if move < 1 or move > col:
raise ValueError
else:
return move - 1
except ValueError:
ASCIIDisplay.invalid_move_out_of_bounds()
continue
def make_move(self, x, p):
'''Give the column to drop and the piece to be dropped into the board
Should engage the physics logic of the cells'''
if not self.cells[x][self.rows - 1].empty():
ASCIIDisplay.col_full_error(x)
return False
for y in range(self.rows):
if self.cells[x][y].empty():
Board.add_piece(self, x, y, p)
return True
else:
continue
def spacing(board_spacing):
"""
Prompt for valid spacing of each cell in the board.
:param board_spacing: Spacing of each cell in the board.
:return: ASCIIDisplay of the board with valid, specified spacing.
"""
while 1:
if board_spacing < 0:
board_spacing = ASCIIDisplay.invalid_spacing_error()
board_spacing = ASCIIDisplay.prompt_for_spacing()
continue
if board_spacing > 2:
board_spacing = ASCIIDisplay.invalid_spacing_error()
board_spacing = ASCIIDisplay.prompt_for_spacing()
continue
elif 0 <= board_spacing <= 2:
display = ASCIIDisplay(board_spacing)
print("Type the column in which you wish to move.")
break
else:
board_spacing = ASCIIDisplay.prompt_for_spacing()
continue
return display
def play_game(self):
turn_counter = 1
self.displayDriver.printState(self.b)
while True:
# Each Player gets their turn
for p in range(0, len(self.players)):
# check if game was draw
if turn_counter == 43:
ASCIIDisplay.draw_msg()
if KeyboardConsoleInput.read_play_again():
return True
else:
return False
ConnectFourRunner.player_turn(self, turn_counter,
self.players[p])
self.displayDriver.printState(self.b)
if ConnectFourRunner.check_if_winner(self, self.players[p]):
if KeyboardConsoleInput.read_play_again():
return True
else:
return False
turn_counter += 1
def reinitialize(board, board_spacing, red_player, black_player):
"""
Reinitialize the board with the same spacing number.
:param board: Board being utilized throughout the game.
:param board_spacing: Spacing of each cell in the board.
:param red_player: Red player object.
:param black_player: Black player object.
:return: None.
"""
board.makeAllSlotsOpen()
display = ASCIIDisplay(board_spacing)
ConnectFour.take_turns(board, board_spacing, display, red_player, black_player)
def play_game(self):
"""
Initialize a new board, red and black players, choose spacing, display the board, and play the game.
:return: None
"""
board = Board(7, 6)
red_player = Player(1, 'R')
black_player = Player(2, 'B')
board_spacing = ASCIIDisplay.prompt_for_spacing()
display = self.spacing(board_spacing)
self.take_turns(board, board_spacing, display, red_player, black_player)
from ASCIIDisplay import ASCIIDisplay
from GameController import Connect_four_Runner
debug_flag = False
if __name__ == "__main__":
d = ASCIIDisplay(2) #display driver
#d.printState(b)
r = Connect_four_Runner(d)
r.play_game()
def check_if_winner(self, player):
if self.b.check_if_winner(self.current_move, player):
ASCIIDisplay.win_msg(player.playerName)
return True
else:
return False
def take_turns(board, board_spacing, display, red_player, black_player):
"""
Prompt both players to take turns throughout the entire duration of the game.
:param board: Board being utilized throughout the game.
:param board_spacing: Spacing of each cell in the board.
:param display: ASCIIDisplay
:param red_player: Red player object
:param black_player: Black player object
:return: None
"""
column = None
turn_count = 1
while 1:
if turn_count % 2 == 1:
display.printState(board)
column = red_player.chooseMove(turn_count)
while 1:
if column < 1 or column > 7:
column = ASCIIDisplay.invalid_move_out_of_bounds()
column = red_player.chooseMove(turn_count)
else:
red_piece = Piece(column, board, 1, 'R')
if board.makeMove(column, red_piece) is True:
if board.checkIfWinner(red_piece) is False and board.numSlotsRemaining() == 0:
display.printState(board)
option = raw_input("Tie Game! Play again? (y/n): ")
while 1:
if option == 'y':
ConnectFour.reinitialize(board, board_spacing, red_player, black_player)
elif option == 'n':
print "Goodbye!"
exit(-1)
else:
option = ASCIIDisplay.invalid_yes_or_no_option()
option = raw_input("Tie Game! Play again? (y/n): ")
elif board.checkIfWinner(red_piece):
display.printState(board)
option = raw_input("Player 1 Wins! Play again? (y/n): ")
while 1:
if option == 'y':
ConnectFour.reinitialize(board, board_spacing, red_player, black_player)
elif option == 'n':
print "Goodbye!"
exit(-1)
else:
option = ASCIIDisplay.invalid_yes_or_no_option()
option = raw_input("Player 1 Wins! Play again? (y/n): ")
break
else:
column = ASCIIDisplay.col_full_error(column)
column = black_player.chooseMove(turn_count)
turn_count += 1
if turn_count % 2 == 0:
display.printState(board)
column = black_player.chooseMove(turn_count)
while 1:
if column < 1 or column > 7:
column = ASCIIDisplay.invalid_move_out_of_bounds()
column = black_player.chooseMove(turn_count)
else:
black_piece = Piece(column, board, 2, 'B')
if board.makeMove(column, black_piece) is True:
if board.checkIfWinner(black_piece) is False and board.numSlotsRemaining() == 0:
display.printState(board)
option = raw_input("Tie Game! Play again? (y/n): ")
while 1:
if option == 'y':
ConnectFour.reinitialize(board, board_spacing, red_player, black_player)
elif option == 'n':
print "Goodbye!"
exit(-1)
else:
option = ASCIIDisplay.invalid_yes_or_no_option()
option = raw_input("Tie Game! Play again? (y/n): ")
elif board.checkIfWinner(black_piece):
display.printState(board)
option = raw_input("Player 2 Wins! Play again? (y/n): ")
while 1:
if option == 'y':
ConnectFour.reinitialize(board, board_spacing, red_player, black_player)
elif option == 'n':
print "Goodbye!"
exit(-1)
else:
option = ASCIIDisplay.invalid_yes_or_no_option()
option = raw_input("Player 2 Wins! Play again? (y/n): ")
break
else:
column = ASCIIDisplay.col_full_error(column)
column = black_player.chooseMove(turn_count)
turn_count += 1
def get_piece_to_add(self):
for p in self.pieces:
if p.col == -1 and p.row == -1:
return p
ASCIIDisplay.piece_limit_error()