def run_network_connectfour():
''' Initiates the ConnectFour program that connects to a server
'''
Connection = _valid_connection()
if Connection != None:
Username = connectfour_server_protocol.username()
connectfour_server_protocol.hello(Connection, Username)
connectfour_server_protocol.request(Connection, 'AI_GAME')
print()
print('Welcome to ConnectFour!')
print()
print('Let\'s begin!')
gameBoard = connectfour.new_game()
connectfour_server_protocol.networkGame(Connection, gameBoard)
connectfour_server_protocol.close(Connection)
else:
print('Closing program.')
def start_game() -> None:
"""
The main entry point for the program.
Starts the console version of the connect four game.
"""
print("Welcome to ICS 32 Connect Four!")
gameState = connect.new_game()
while connect.winner(gameState) == connect.NONE:
lib.print_game_state(gameState)
print('')
lib.print_turn(gameState)
while True:
col, move = lib.prompt_and_get_move()
try:
gameState = lib.execute_move(gameState, col, move)
break
except connect.InvalidMoveError:
if move == lib.POP_BOTTOM:
print('Can not pop on the given column')
else:
print('Can not drop on the given column')
winner = connect.winner(gameState)
print()
lib.print_game_state(gameState)
print(lib.get_player_string(winner) + ' has won the game! Congrats!')
return
def run_user_interface() -> None:
'Starts the console veresion of connectfour'
game_state = connectfour.new_game()
print("Columns should be selected by typing a number between 1 and 7")
print("Specify a move in the format of DROP col# or POP col#")
print("replace col# with the column's number that you want selected")
turn = 0
while (connectfour.winner(game_state) == connectfour.NONE):
if turn % 2 == 0:
print('______________________')
print("PLAYER RED'S TURN")
else:
print('______________________')
print("PLAYER YELLOW'S TURN")
user_input = input('Enter a move: ')
game_state = shared_functions.process_user_input(
game_state, user_input)
shared_functions.print_game_board(game_state)
turn += 1
winner = connectfour.winner(game_state)
if winner == 1:
winner_color = 'PLAYER RED'
else:
winner_color = 'PLAYER YELLOW'
print('Congratulations ' + winner_color + ', you are the winner!')
def online_gameplay(connection: connectfour_socket.GameConnect):
'''Runs the Connect Four game on the user interface.'''
game_state = connectfour.new_game()
x = 0
connectfour_gameplay.numbers(x)
connectfour_gameplay.dot_rows(game_state)
while True:
x = connectfour_gameplay.name_turn(game_state)
if x == connectfour.RED:
game_state = red_turn(game_state, connection)
connectfour_gameplay.numbers(x)
connectfour_gameplay.dot_rows(game_state)
x = connectfour.winner(game_state)
elif x == connectfour.YELLOW:
game_state = yellow_turn(game_state, connection)
connectfour_gameplay.numbers(x)
connectfour_gameplay.dot_rows(game_state)
x = connectfour.winner(game_state)
elif x == connectfour.NONE:
print('hi')
if x == connectfour.NONE:
continue
elif x == connectfour.RED:
print('GAME OVER. The winner is red.')
break
elif x == connectfour.YELLOW:
print('GAME OVER. The winner is yellow player.')
break
connectfour_gameplay.name_turn(game_state)
def execute_game(connection: 'connection'):
'''Execution block of the network version of Connect Four game.
Takes turns between user and server until server detects a winner.'''
game_state = connectfour.new_game()
connectfour_functions.print_board(game_state)
print()
winner = connectfour.NONE
server_response = ''
while (winner == connectfour.NONE):
game_over = check_game_over(server_response)
if game_over == True:
break
if game_state.turn == connectfour.RED:
print('It is Red Player\'s turn')
game_state = user(connection, game_state)
server_response = connectfour_network.receive_response(connection)
if game_state.turn == connectfour.YELLOW:
while server_response != 'OKAY':
server_response = connectfour_network.receive_response(connection)
print('It is Yellow Player\'s turn')
game_state = server(connection, game_state)
server_response = connectfour_network.receive_response(connection) #OKAY or READY
connectfour_functions.print_board(game_state)
def main_game() -> None:
'''Show user interface to the players'''
_show_welcome_banner()
game_state = connectfour.new_game()
while True:
common_functions.show_board(game_state)
if _player_turns(game_state) == 1:
print("It's RED turn.")
elif _player_turns(game_state) == 2:
print("It's YELLOW turn.")
print()
column_num = common_functions.choose_column()
action = common_functions.choose_action()
game_state = common_functions.make_action(game_state, column_num,
action)
winner = connectfour.winner(game_state)
if winner != connectfour.NONE:
common_functions.show_board(game_state)
common_functions.stop_game(winner)
break
def main_game(connection: I32CFSP.Connectfourconnection) -> None:
'''Show user interface to the player'''
game_state = connectfour.new_game()
common_functions.show_board(game_state)
return_message = I32CFSP.read_line(connection)
while True:
if return_message == 'READY':
print("It's RED(You)'s turn")
print()
game_state = _player_turns(connection, game_state)
common_functions.show_board(game_state)
return_message = I32CFSP.read_line(connection)
elif return_message == 'INVALID':
return_message = I32CFSP.read_line(connection)
elif return_message == 'OKAY':
game_state = _AI_turns(connection, game_state)
common_functions.show_board(game_state)
return_message = I32CFSP.read_line(connection)
elif return_message == 'WINNER_RED':
common_functions.stop_game(connectfour.RED)
break
elif return_message == 'WINNER_YELLOW':
common_functions.stop_game(connectfour.YELLOW)
break
def gameplay():
'''
This function processes the entire game with the AI as well as the setting
up of the game.
'''
try:
connection_and_username = begin_game()
connection = connection_and_username[0]
username = connection_and_username[1]
except InvalidServerError:
return
ai_gamestate = connectfour.new_game()
while(connectfour.winner(ai_gamestate) == connectfour.NONE):
try:
ai_gamestate = _user_turn(ai_gamestate, connection, username)
print()
except connectfour_protocol.ConnectFourProtocolError:
print('Invalid Input. Please Try Again.')
except connectfour_protocol.InvalidServerMoveError:
print('Invalid Input. Please Try Again.')
except InvalidServerError:
return
connectfour_shared.print_board(ai_gamestate)
print()
if(connectfour.winner(ai_gamestate) == connectfour.RED):
print('Congratulations! You have won the game!')
else:
print('Sorry. The AI has won the game.')
connectfour_protocol.disconnect(connection)
def movement() -> str:
''' allows the player to pop or drop a disc into a given column
and determines the winner'''
gs = connectfour.new_game()
connectfour_board.print_board(gs.board)
print('If you want to drop type D, press enter and a column number.')
print('If you want to pop type P, press enter and a column number.')
while True:
try:
command = input()
col = int(input())
if command[0] == 'D':
gs = connectfour.drop(gs, col - 1)
connectfour_board.print_board(gs.board)
else:
gs = connectfour.pop(gs, col - 1)
connectfour_board.print_board(gs.board)
if connectfour.winner(gs) != connectfour.NONE:
x = connectfour.winner(gs)
if x == 1:
print('RED WINS!')
elif x == 2:
print('YELLOW WINS!')
return command + ' ' + col
except ValueError:
print('Try again')
pass
def start_game()->connectfour.GameState:
'''
creates new game and displays a blank board
'''
game = connectfour.new_game()
display_board(game)
return game
def start_game(connection: connect_four_protocol.Connection,) -> None:
''' start the game and handle the move made by the players '''
_game = connectfour.new_game()
my_connectfour.print_game_board(_game)
_game = client_turn(connection, _game)
while True:
winner = connectfour.winner(_game)
if winner == 1:
my_connectfour.print_game_board(_game)
print('You (Red Player) won')
break
elif winner == 2:
print('Player Yellow won')
break
else:
my_connectfour.print_game_board(_game)
AI_message = connect_four_protocol.recv_message(connection)
if AI_message == "OKAY":
_new_game = server_turn(connection,_game)
_game = _new_game
my_connectfour.print_game_board(_game)
AI_message = connect_four_protocol.recv_message(connection)
if AI_message == "READY":
print("Player red's turn ")
_game = client_turn(connection, _game)
print()
def start_game(connection: connect_four_protocol.connection) -> None:
''' start the game and handle the move made by the players '''
game = connectfour.new_game()
connectfour.print_game_board(game)
while True:
my_connectfour.print_game_board(game)
if(game.turn == 1):
print("Player Red Turn")
elif(game.turn == 2):
print("Player Yellow Turn")
print()
column = my_connectfour.get_column()
move = my_connectfour.select_move()
game = my_connectfour.handle_move(game,column, move)
my_connectfour.winner = connectfour.winner(game)
if my_connectfour.winner != connectfour.NONE:
my_connectfour.print_game_board(game)
my_connectfour.game_over()
break
def main() -> None:
# Connect to server
while True:
connection = net_utils.connect_to_server()
if connection != None:
user = net_utils.get_username()
if net_utils.start_game(connection, user):
break
else:
return
# Test code
#connection = net_utils._open_connection("woodhouse.ics.uci.edu", 4444)
#user = "******"
#net_utils.start_game(connection, user)
#random.seed(calendar.timegm(time.gmtime()))
# Variable Initialization
winner = game.NONE
players = ("RED", "YELLOW")
player_names = {"RED": user, "YELLOW": "Server AI"}
server_turn = False
player_move = None
input_format = "[{{}}] {}:".format(user)
utils.print_instructions()
game_state = game.new_game()
while winner == game.NONE:
utils.print_board(game_state.board)
# Receive player moves and execute server side
if not server_turn:
# Test bot code
#player_move = get_random_move()
player_move = utils.get_input(game_state,players[server_turn], input_format)
else:
player_move = net_utils.sync_move(connection, player_move.action, player_move.col)
print('[{}] {}: {} {}'.format(players[server_turn], \
player_names[players[server_turn]], \
player_move.action.title(), \
(player_move.col + 1)))
# Execute player moves
try:
game_state = utils.execute_move(game_state,player_move)
winner = game.winner(game_state)
except game.InvalidMoveError:
print("[Connect Four] Invalid move")
continue
server_turn = not server_turn
# Sync final moves to server and validate
# the winner remotely and locally
player_move = net_utils.sync_move(connection, player_move.action, player_move.col)
utils.print_board(game_state.board)
_validate_winner(players[winner-1],player_move.winner,player_names)
net_utils.end_game(connection)
def run_user_interface() -> None:
'''Runs the user interface and maintains the game until end.'''
host = socketHandling.input_host()
port = socketHandling.input_port()
print('Connecting to {} (port {})...'.format(host, port))
connection = socketHandling.connect(host, port)
print('Connection successful.')
name = socketHandling.input_username()
is_connected = socketHandling.initial_protocol(connection, name)
if is_connected != False:
overlappingFunctions.print_welcome_message()
gstate = connectfour.new_game()
overlappingFunctions.display_board(gstate)
while is_connected != False and connectfour.winner(
gstate) == connectfour.NONE:
if gstate.turn == connectfour.RED:
GamePlusMove = overlappingFunctions.execute_move(gstate)
socketHandling.send_message(connection, GamePlusMove.move)
gstate = GamePlusMove.GameState
overlappingFunctions.display_board(gstate)
elif gstate.turn == connectfour.YELLOW:
response = socketHandling.receive_response(connection)
gstate = interpret_response(connection, response, gstate)
overlappingFunctions.display_board(gstate)
if is_connected != False:
overlappingFunctions.print_winner(gstate)
def run_game() -> None:
''' Starts a local game '''
utils.print_instructions()
game_state = game.new_game()
winner = game.NONE
players = ("RED", "YELLOW")
yellow_turn = False
while winner == game.NONE:
utils.print_board(game_state.board)
player_move = utils.get_input(game_state,players[yellow_turn])
# Select a player action
try:
game_state = utils.execute_move(game_state,player_move)
except game.InvalidMoveError:
print("[Connect Four] Invalid move")
continue
# Swap players
yellow_turn = not yellow_turn
winner = game.winner(game_state)
utils.print_board(game_state.board)
winner_name = 'NONE'
if winner == game.RED:
winner_name = 'RED'
elif winner == game.YELLOW:
winner_name = 'YELLOW'
print('[Connect Four] Winner: {}'.format(winner_name))
def _gameloop() -> None:
game_state = connectfour.new_game()
connection = protocol.connect('woodhouse.ics.uci.edu', 4444)
protocol.ready_game(connection)
while True:
common.display_game_board(game_state.board)
if game_state.turn == connectfour.RED:
try:
game_state = _handle_red(game_state, connection)
except:
common.print_general_err()
continue
elif game_state.turn == connectfour.YELLOW:
try:
game_state = _handle_yellow(game_state, connection)
except:
print('The server returned an invalid move, closing connection')
protocol.close(connection)
break
response = protocol.get_response(connection)
if _handle_server_responses(response):
common.display_game_board(game_state.board)
protocol.close(connection)
break
def user_interface()->None:
''' main part of the program that controls the game functionality'''
print("Welcome to ConnectFour Game...\n")
game = connectfour.new_game()
while True:
my_connectfour.print_game_board(game)
if(game.turn == 1):
print("Player Red Turn")
elif(game.turn == 2):
print("Player Yellow Turn")
column = my_connectfour.get_column()
move = my_connectfour.select_move()
game = my_connectfour.handle_move(game,column, move)
my_connectfour.winner = connectfour.winner(game)
if my_connectfour.winner != 0:
my_connectfour.print_game_board(game)
my_connectfour.game_over(my_connectfour.winner)
break
def main():
connection = net_tools.connect()
user = input("please input a username: "******"I32CFSP_HELLO " + user)
check_input(connection, "WELCOME " + user)
net_tools.send_output(connection, "AI_GAME")
#check_input(connection,"READY")
game = connectfour.new_game()
while True:
response = net_tools.receive_input(connection)
if response == "READY":
move = user_input(connection)
response = net_tools.receive_input(connection)
if response == "OKAY":
game = user_move(game, move)
connectfour_tools.print_game(game)
game = server_move(game, connection)
connectfour_tools.print_game(game)
elif response == "INVALID":
print("Invalid move")
elif response == "WINNER_RED":
break
else:
print('Sorry! something went wrong with the server.')
net_tools.close_connection(connection)
elif response == "WINNER_YELLOW":
break
else:
print('Sorry! something went wrong with the server.')
net_tools.close_connection(connection)
print(response)
connectfour_tools.print_game(game)
net_tools.close_connection(connection)
def connect_four_consoleUI():
''' This is the main user interface where the program is executed and the Connect Four
game runs with all its respective functions '''
WelcomeBanner() # prints welcome banner
print()
PlayerRed = InputRed() # creates player 1 - red
PlayerYellow = InputYellow() # creates player 2 - yellow
print()
GameState = connectfour.new_game() # starts a new game and prints an empty board
Project2commonUI.printBoard(GameState.board)
while True:
PlayerTurn(GameState, PlayerRed, PlayerYellow) # function call to PlayerTurn() which determines whose turn it is
message = input()
message = message.upper() # prompts for input to drop/pop a piece
try:
if len(message) == 0: # if there is nothing, this error is printed.
print('\nSorry invalid input. Try again. :p\n')
else:
Responses = message.split() # otherwise the move is placed on the board and printed through InputMove()
GameState = InputMove(Responses, GameState)
except connectfour.InvalidMoveError:
print('Invalid move! Try again. :p\n[ You can only POP your own piece or DROP a piece in an empty column! ]') # error for invalid move
except ValueError:
print('Invalid column number! Try again. :p\n[ Number must be 1, 2, 3, 4, 5, 6, or 7! ]\n') # error for value error - wrong col num.
finally:
Finale = WinningBanner(GameState, PlayerRed, PlayerYellow) # prints the banner and returns the exit string
if Finale == 'You may exit the program!': # if exit string is correct then the program breaks and ends.
break
def run_game() -> None:
''' Starts a local game '''
utils.print_instructions()
game_state = game.new_game()
winner = game.NONE
players = ("RED", "YELLOW")
yellow_turn = False
while winner == game.NONE:
utils.print_board(game_state.board)
player_move = utils.get_input(game_state, players[yellow_turn])
# Select a player action
try:
game_state = utils.execute_move(game_state, player_move)
except game.InvalidMoveError:
print("[Connect Four] Invalid move")
continue
# Swap players
yellow_turn = not yellow_turn
winner = game.winner(game_state)
utils.print_board(game_state.board)
winner_name = 'NONE'
if winner == game.RED:
winner_name = 'RED'
elif winner == game.YELLOW:
winner_name = 'YELLOW'
print('[Connect Four] Winner: {}'.format(winner_name))
def main():
overlap.welcome_banner()
overlap.explain_rules()
gamestate = connectfour.new_game()
while True:
overlap.display_current_board(gamestate)
overlap.print_whose_turn(gamestate)
gamestate = run_turn(gamestate)
def console_user_interface() -> None:
'''Runs console user interface'''
print('Welcome to Connect-Four!')
print('One player will use Red pieces designated by R \n' +
'while another player will use Yellow pieces designated by Y')
new_GameState = connectfour.new_game()
print('Here is the starting game board: \n')
connectfour_modules.display_game_board(new_GameState.board)
run_turn(new_GameState)
def playConnectFour():
GameState = connectfour.new_game() #changed to game state
while connectfour.winner(GameState) == 0: #changed to game state
GameState = connectfour_functions.playerMove(
GameState) #both changed to gamestate
connectfour_functions.displayBoard(GameState) #changed to game state
if connectfour.winner(GameState) == 1:
print("RED player wins!")
elif connectfour.winner(GameState) == 2:
print("YELLOW player wins!")
def start_game() -> None:
"""
The main entry point for the program.
Starts the networked version of the connect four game.
"""
print("Welcome to ICS 32 Connect Four!")
host, port = get_address_and_port()
username = get_username()
if not network.connect_to_game_server(host, port, username):
print('A connection could not be established with the server')
return
print('Successfully connected to the server. Ready to begin the game.')
print('')
gameState = connectfour.new_game()
while connectfour.winner(gameState) == connectfour.NONE:
if gameState.turn == connectfour.RED:
lib.print_game_state(gameState)
print('')
print('You are the Red player. It is your move.')
while True:
col, move = lib.prompt_and_get_move()
response = network.send_move(move, col)
if response == network.TERMINATED:
connection_terminated()
return
elif response == network.ILLEGAL:
print("Invalid move. Try again.")
else:
gameState = lib.execute_move(gameState, col, move)
break
else:
lib.print_game_state(gameState)
print('')
move, col = network.receive_move()
if move == network.TERMINATED:
connection_terminated()
return
gameState = lib.execute_move(gameState, col, move)
print('The Yellow player has made the move: ' + move + ' ' +
str(col))
winner = connectfour.winner(gameState)
print()
lib.print_game_state(gameState)
print('')
if winner == connectfour.RED:
print('You have won the game! Congrats!')
else:
print('The Yellow player has won the game.')
network.terminate_connection()
return
def main():
game = connectfour.new_game()
while True:
game = input_move(game)
connectfour_tools.print_game(game)
if connectfour.winner(game) == connectfour.RED:
print("RED wins! Congratulations!")
break
elif connectfour.winner(game) == connectfour.YELLOW:
print("YELLOW wins! Congratulations!")
break
def run_user_interface() -> None:
'''Runs the user interface and maintains the game until end.'''
overlappingFunctions.print_welcome_message()
game_state = connectfour.new_game()
overlappingFunctions.display_board(game_state)
while connectfour.winner(game_state) == connectfour.NONE:
GamePlusMove = overlappingFunctions.execute_move(game_state)
game_state = GamePlusMove.GameState
overlappingFunctions.display_board(game_state)
else:
overlappingFunctions.print_winner(game_state)
def initializeGame():
'''Begins the game by asking for the host,port, and username and finally creates a new GameState with the new connection'''
while True:
host = _prompt_For_Host()
port = _prompt_For_Port()
try:
connection = lab2_socket.connect(host, port)
break
except:
print("The connection could not be made. Please try again.")
lab2_socket.hello(connection, _prompt_For_Username())
playGame(connection, connectfour.new_game())
def initializeGame():
'''Begins the game by asking for the host,port, and username and finally creates a new GameState with the new connection'''
while True:
host = _prompt_For_Host()
port = _prompt_For_Port()
try:
connection = lab2_socket.connect(host, port)
break
except:
print("The connection could not be made. Please try again.")
lab2_socket.hello(connection, _prompt_For_Username())
playGame(connection, connectfour.new_game())
def startgame() -> None:
game_state = connectfour.new_game()
connectfour_game.print_board(game_state)
while connectfour.winner(game_state) == 0:
connectfour_game.print_turn(game_state)
move = connectfour_game.drop_or_pop()
column_number = connectfour_game.ask_column()
game_state = connectfour_game.game_progress(game_state,move,column_number)
connectfour_game.print_board(game_state)
if connectfour.winner(game_state) == 1:
print('RED WINS!')
elif connectfour.winner(game_state) == 2:
print('YELLOW WINS!')
def start_game(new_g: bool):
''' start the game'''
print("\nWe are going to play Connect Four.\nRed always goes first.")
#makes our gameboard, starts with all empty
GS = connectfour.new_game()
#prints player turn
print_player_turn(GS, new_g)
#prints the empty board
print_screen(GS)
return GS
def _run_interface():
game_state = connectfour.new_game()
while True:
cf_functions.print_board(game_state)
gs_dp_col = cf_functions.move(game_state)
game_state = gs_dp_col[0]
win = connectfour.winner(game_state)
if win == connectfour.RED:
print('Player R has won the game.')
break
elif win == connectfour.YELLOW:
print('Player Y has won the game.')
break
def run():
'''runs game against the server using hidden functions'''
try:
host = input('Enter host: ')
port = input('Enter port: ')
connected = serverlogic.connect(host, int(port))
game_state = connectfour.new_game()
username = serverlogic.get_username()
serverlogic.login(connected, username)
serverlogic.send(connected)
except:
print("--Invalid Input--")
else:
while connectfour.winner(game_state) == connectfour.NONE:
try:
print()
print("Turn:RED")
print()
popdrop, column_number = C4BG.userinput()
print()
game_state = C4BG.change_board(game_state, popdrop,
column_number)
except:
print("Please re-enter")
else:
print('-------------------')
print()
print("Yellow's turn")
print()
print("Server Response:")
to_server = popdrop.upper() + ' ' + str(column_number)
serv_response = serverlogic.server_popdrop(
connected, to_server)
print()
if serv_response == 'WINNER_RED':
serverlogic.closeconnection(connected)
break
if serv_response == 'WINNER_YELLOW':
serverlogic.closeconnection(connected)
break
if serv_response != 'READY':
server_drop = serv_response.split()[0]
server_column = serv_response.split()[1]
game_state = C4BG.change_board(game_state, server_drop,
server_column)
def _start_game(connection: connectfour_socket.ConnectfourConnection) -> None:
game_state = connectfour.new_game()
connectfour_game.print_board(game_state)
while connectfour.winner(game_state) == 0:
if connectfour_socket.AI_ready(connection):
connectfour_game.print_turn(game_state)
game_state, response = _player_turn(connection, game_state)
if response == 'OKAY':
connectfour_game.print_turn(game_state)
game_state = _AI_turn(connection, game_state)
if connectfour.winner(game_state) == 1:
print('RED wins!')
elif connectfour.winner(game_state) == 2:
print('YELLOW wins!')
def game(connection: 'connection') -> None:
'''goes through server version of connect four'''
intromessage(connection)
print('Welcome to Connect 4!')
print('You are the RED player!')
gamestate = connectfour.new_game()
connectfour_common.print_game_board(gamestate.board)
connectfour_network.send_message(connection, ('AI_GAME'))
while True:
a = connectfour_network.read_message(connection)
if (a) == 'READY':
print('\nIt is the', connectfour_common.getturn(gamestate),
'players turn!')
answer = input(
'Choose if you want to DROP or POP and a column between 1 and '
+ str(connectfour.BOARD_COLUMNS) + '. (Ex. DROP 4)"\n')
answer = isvalid(answer)
anslist = answer.split()
connectfour_network.send_message(connection, answer)
try:
c = (int(anslist[1]) - 1)
gamestate = connectfour_common.doingmove(
anslist[0], c, gamestate)
connectfour_common.print_game_board(gamestate.board)
except:
pass
elif a == 'OKAY':
print('\nIt is the', connectfour_common.getturn(gamestate),
'players turn!\n')
output = connectfour_network.read_message(connection)
move = printturn(output, gamestate, connection)
col = (int(move[1]) - 1)
gamestate = connectfour_common.doingmove(move[0], col, gamestate)
connectfour_common.print_game_board(gamestate.board)
elif a == 'INVALID':
print('Invalid choice choose again.')
elif a == "WINNER_RED":
print('GAME OVER! You are the winner!')
connectfour_network.close(connection)
break
elif a == "WINNER_YELLOW":
print('GAME OVER! YOU LOST! Yellow player is the winner!')
connectfour_network.close(connection)
break
elif a == ('ERROR'):
print('Invalid choice choose again')
pass
def game():
'''plays the game'''
gameboard = connectfour.new_game()
connectfour_opp.display_board(gameboard)
while True:
try:
gameboard = connectfour_opp.move_user_red(gameboard)[0]
connectfour_opp.display_board(gameboard)
print()
gameboard = connectfour_opp.move_user_yellow(gameboard)
connectfour_opp.display_board(gameboard)
print()
except:
break
def _begin_game() -> connectfour.GameState:
'''
This program begins the console game of Connect Four. It starts with a
greeting and a brief summary of directions in order to play the game.
The function ends by returning a board of a new game.
'''
print('Welcome to Connect Four!', end='\n\n')
print(
'Please enter the action you want to take. The two actions avaliable' +
' are DROP and POP. DROP is to place a disc in a specified column and'
+ ' POP is to take out your own disc at a specified column.\n')
board_game = connectfour.new_game()
return board_game
def each_turn() -> None:
'''
Simulates turn for each player, updates gamestate, displays the
board for the user to see and shows whose turn it is. Breaks and
Displays the winner when the game is won.
'''
game = connectfour.new_game()
while True:
common.display_turn(game)
player_move = common.interpret_user_input()
if player_move.Action == 'D':
try:
game = connectfour.drop(game, player_move.Col_Num)
print()
common.board_display(game)
except:
print('Invalid Move')
elif player_move.Action == 'P':
try:
game = connectfour.pop(game, player_move.Col_Num)
print()
common.board_display(game)
except:
print('Invalid Move')
else:
print('Try again')
if winner(game):
break
def new_game_state():
'''New game state of ConnectFour'''
return connectfour.new_game()
def new_game_state():
return connectfour.new_game()
#Ryan Yue 69858941
#Hubert Cheng 12885496
import lab2_connectfourgame
import connectfour
def playGame(gamestate: connectfour.GameState):
'''Calls functions from lab2_connectfourgame.py to play a console version of connectfour'''
lab2_connectfourgame.printBoard(gamestate)
while(lab2_connectfourgame.checkWin(gamestate)):
user_action, col_num = lab2_connectfourgame.getUserInput()
if (lab2_connectfourgame.checkMove(gamestate, user_action, col_num)):
gamestate = lab2_connectfourgame.makeMove(gamestate, user_action, col_num)
lab2_connectfourgame.printBoard(gamestate)
else:
print("Please enter a valid move")
lab2_connectfourgame.printWinner(gamestate)
if __name__ == '__main__':
playGame(connectfour.new_game())
# Mahamadou Sylla
import connectfour
import sharedfunctions
game = connectfour.new_game() # brand new game of connect four
def program(game):
"""
program that handles the connect four game
"""
while connectfour.winner(game) == 0: # while there is no winner
if game.turn == 1: # if it is red player's turn
print("Player RED make your move") # prints this message
print()
elif game.turn == 2: # if it is yellow players turn
print("Player YELLOW make your move") # prints this message
print()
sharedfunctions.print_board(game.board) # print a new game
current_move = sharedfunctions.get_move() # gets the players move and stores it in a variable
while True:
try:
if current_move[0].upper() == "DROP": # if players says they want to drop
game = connectfour.drop(
game, int(current_move[-1]) - 1
) # drops the players move in appropriate column and changes the game state
elif current_move[0].upper() == "POP": # if player says they want to pop
# SHAMBHU THAPA 10677794 , DANIEL RAMIREZ 57298305
import connectfour
_game = connectfour.new_game()
game_winner = connectfour.winner(_game)
def print_game_board(_game: 'connectfour.ConnectFourGameState') -> None:
''' Displays the game state as the game is running '''
print()
for i in range(connectfour.BOARD_COLUMNS):
print(i+1, end = ' ')
print()
for row in range(connectfour.BOARD_ROWS):
for col in range(connectfour.BOARD_COLUMNS):
if _game.board[col][row] == connectfour.NONE:
print('.', end = ' ')
elif _game.board[col][row] == connectfour.RED:
print('R', end=' ')
elif _game.board[col][row] == connectfour.YELLOW:
print('Y', end=' ')
else:
print(_game.board[col][row], end =' ')
print()
print()
def get_column() ->int:
''' prompt the user to choose a desired column'''
import connectfour
rows = connectfour.BOARD_ROWS
columns = connectfour.BOARD_COLUMNS
new_board = connectfour.new_game()
def userInput():
## game_board = new_board
## while winner_is_chosen(game_board) == False:
userInput = input('Please choose which column number from 1-7:\n').strip().lower()
usercommand = userInput.split()
if usercommand[0] == 'drop':
pieces_drop = drop_piece(int(usercommand[1]) - 1)
game_board = print_board(pieces_drop)
elif usercommand[0] == 'pop':
pop_piece(int(usercommand[1]) - 1)
else:
pass
def drop_piece(col_num: int):
new_state = connectfour.drop(new_board, col_num)
return new_state
def pop_piece(col_num: int):
new_state = connectfour.pop(new_board, col_num)
return pop_piece
def print_board(game_state):
# this function will format the board later on
print(game_state.board)
board_state = game_state.board
import connectfour
import collections
Move = collections.namedtuple('Move', ['Action', 'Col_Num'])
original_gamestate = connectfour.new_game()
game_state = connectfour.GameState
num = [1,2,3,4,5,6,7]
def board_display (gs: connectfour.GameState) -> None:
'''
Displays the board from the parameter GameState
'''
board = gs.board
for pick in num:
print(pick, end = ' ')
print()
for row in range(connectfour.BOARD_ROWS):
for col in range(connectfour.BOARD_COLUMNS):
if board[col][row] == connectfour.NONE:
print('.', end = ' ')
if board[col][row] == connectfour.RED:
print('R', end = ' ')
if board[col][row] == connectfour.YELLOW:
print('Y', end = ' ')
print()
def display_turn(gs: connectfour.GameState) -> str:
'''Displays who's turn it is to play'''
