def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. >>> m = TOAHModel(2) >>> m.fill_first_stool(1) >>> m.top_cheese(0) Cheese(1) >>> move(m, 0, 1) >>> m.top_cheese(1) Cheese(1) ''' # Try to make the move with model try: model.move(origin, dest) except IllegalMoveError as e: # Print the error message print("Illegal Move:", e) return
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float = 0.5, console_animate: bool = False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to animate the tour in the console delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ n = model.number_of_cheeses() list_of_moves = moves_list(n, 0, 1, 2, 3) if console_animate: for move in list_of_moves: TOAHModel.move(model, move[0], move[1]) print(model) print('Moving top cheese from {} to {}'.format(move[0], move[1])) time.sleep(delay_btw_moves) else: for move in list_of_moves: TOAHModel.move(model, move[0], move[1]) print('Moving top cheese from {} to {}'.format(move[0], move[1]))
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float = 0.5, console_animate: bool = False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to use ConsoleController to animate the tour delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ #This first part is to make the right MoveSequence cheese_num = model.number_of_cheeses() moves = MoveSequence([]) four_stool_solution(moves, cheese_num, 0, 1, 2, 3) #Then we apply it to our existing model, animating with delay if #requested. if console_animate: for move in moves._moves: print(model) model.move(move[0], move[1]) time.sleep(delay_btw_moves) print(model) else: for move in moves._moves: model.move(move[0], move[1])
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. >>> M = TOAHModel(4) >>> M.fill_first_stool(5) >>> M.move(0,2) >>> M.get_move_seq() MoveSequence([(0, 2)]) >>> M1 = TOAHModel(4) >>> M1.fill_first_stool(5) >>> M1.move(0,2) >>> M1.move(2,1) >>> M1.get_move_seq() MoveSequence([(0, 2), (2, 1)]) ''' has_cheese = False length_of_dest_stool = len(model.stools[dest]) if length_of_dest_stool > 0: has_cheese = True if has_cheese and model.top_cheese(origin).size > model.top_cheese(dest).size: raise IllegalMoveError('Illegal move, try again!') else: relocate = model.stools[origin].pop() model.stools[dest].append(relocate) model.move_count += 1 moves_tup = (origin,dest) model._move_seq.append(moves_tup)
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. ''' try: # one move model.move(origin, dest) model.moves += 1 except IllegalMoveError: print('Please enter the right move') except IndexError: print( 'Please select the origin stool where there is at least one cheese on it' ) print( 'and cannot be out of range(0 to the number of stools you entered before minus 1' ) except ValueError: print( 'Please enter a number within 0 to the number of stools you entered before(without alphabetical letters' )
def move_cheeses(n: int, i, source: int, intermediate1: int, intermediate2, destination: int) -> None: """Print moves to get n cheeses from source to destination, possibly using intermediate""" if i > 1: if n > 1: move_cheeses(n - i, i, source, destination, intermediate1,intermediate2) move_cheeses(i-1, i, source, intermediate2, destination, intermediate1) move_cheeses(1, i, source, intermediate1, intermediate2, destination) move_cheeses(i-1, i, intermediate1, source, intermediate2, destination) move_cheeses(n -i, i, intermediate2, intermediate1, source, destination) else: print("Move top cheese from {} to {}".format(source, destination)) else: # just one cheese --- no recursion required! print("Move top cheese from {} to {}".format(intermediate2, destination) if __name__ == '__main__' : NUM_CHEESES = 8 DELAY_BETWEEN_MOVES = .5 CONSOLE_ANIMATE = False # DO NOT MODIFY THE CODE BELOW. four_stools = TOAHModel(4) four_stools.fill_first_stool(number_of_cheeses=NUM_CHEESES) tour_of_four_stools(four_stools, console_animate=CONSOLE_ANIMATE, delay_btw_moves=DELAY_BETWEEN_MOVES) print(four_stools.number_of_moves())
def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ self.number_of_stools = TOAHModel(number_of_stools) self.number_of_cheeses = \ self.number_of_stools.fill_first_stool(number_of_cheeses)
def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ model = TOAHModel(number_of_stools) model.fill_first_stool(number_of_cheeses) self._model = model
def __init__(self: 'GUIController', number_of_cheeses: int, number_of_stools: int, content_width: float, content_height: float, cheese_scale: float): """ Initialize a new GUIView. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools content_width - width in pixels of the working area content_height - height in pixels of the working area cheese_scale - height in pixels for showing cheese thicknesses, and to scale cheese diameters """ self._model = TOAHModel(number_of_stools) self._stools = [] self._cheese_to_move = None self._blinking = False self._number_of_stools = number_of_stools self.cheese_scale = cheese_scale self.root = TI.Tk() canvas = TI.Canvas(self.root, background="blue", width=content_width, height=content_height) canvas.pack(expand=True, fill=TI.BOTH) self.moves_label = TI.Label(self.root) self.show_number_of_moves() self.moves_label.pack() # the dimensions of a stool are the same as a cheese that's # one size bigger than the biggest of the number_of_cheeses cheeses. for stool_ind in range(number_of_stools): width = self.cheese_scale * (number_of_cheeses + 1) x_cent = content_width * (stool_ind + 1) / (number_of_stools + 1.0) y_cent = content_height - cheese_scale / 2 stool = StoolView(width, lambda s: self.stoolClicked(s), canvas, self.cheese_scale, x_cent, y_cent) self._stools.append(stool) # Can't use self._model.fill_first_stool because we need to # use CheeseView objects instead of just Cheese objects. total_size = self.cheese_scale for sizeparam in range(1, number_of_cheeses + 1): size = (number_of_cheeses + 1 - sizeparam) width = self.cheese_scale * size x_cent = content_width / (number_of_stools + 1.0) y_cent = content_height - cheese_scale / 2 - total_size cheese = CheeseView(size, width, lambda c: self.cheeseClicked(c), canvas, self.cheese_scale, x_cent, y_cent) self._model.add(0, cheese) total_size += self.cheese_scale
def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ self.model = TOAHModel(number_of_stools) self.model.fill_first_stool(number_of_cheeses) self.has_seen_instructions = False
class ConsoleController: def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ self.number_of_stools = TOAHModel(number_of_stools) self.number_of_cheeses = \ self.number_of_stools.fill_first_stool(number_of_cheeses) def play_loop(self: 'ConsoleController'): ''' Console-based game. TODO: -Start by giving instructions about how to enter moves (which is up to you). Be sure to provide some way of exiting the game, and indicate that in the instructions. -Use python's built-in function input() to read a potential move from the user/player. You should print an error message if the input does not meet the specifications given in your instruction or if it denotes an invalid move (e.g. moving a cheese onto a smaller cheese). You can print error messages from this method and/or from ConsoleController.move; it's up to you. -After each valid move, use the method TOAHModel.__str__ that we've provided to print a representation of the current state of the game. ''' print('You will have a number of Cheeses stacked on each other in \ order of size.\n') print('You also have a number of stools and the the goal of the game\ is to get all the Cheeses from one stool to the final stool.\n') print('In the process of this you are not allowed to stack a Cheese\ that is bigger than another.\n') user_string = '' while user_string != 'Exit Game': first_move = input('What is the orgin of the Cheese?:') second_move = input('What is the destination of the Cheese?:') try: self.number_of_stools.move(int(first_move), int(second_move)) except IllegalMoveError: print('You made a mistake, please try again') except ValueError: print('You made a mistake, please change your input to an int') print(self.number_of_stools) print(self.number_of_cheeses) user_string = input('To exit, type Exit Game. Anything 2 continue')
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. ''' model.move(origin, dest)
def move_cheeses(model: TOAHModel, n: int, source: int, intermediate: int, destination: int) -> None: """Print moves to get n cheeses from source to destination, possibly using intermediate""" if n > 1: move_cheeses(model, n - 1, source, destination, intermediate) move_cheeses(model, 1, source, intermediate, destination) move_cheeses(model, n - 1, intermediate, source, destination) else: model.move(source, destination) if animate is True: print(model) time.sleep(delay)
class ConsoleController: def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int) -> None: """ Initialize a new 'ConsoleController'. """ TOAHModel.__init__(self, number_of_stools) TOAHModel.fill_first_stool(self, number_of_cheeses) self.cheese_model = TOAHModel(number_of_stools) self.number_of_stools = number_of_stools self.cheese_model.fill_first_stool(number_of_cheeses) def play_loop(self: 'ConsoleController') -> None: ''' Console-based game. TODO: -Start by giving instructions about how to enter moves (which is up to you). Be sure to provide some way of exiting the game, and indicate that in the instructions. -Use python's built-in function input() to read a potential move from the user/player. You should print an error message if the input does not meet the specifications given in your instruction or if it denotes an invalid move (e.g. moving a cheese onto a smaller cheese). You can print error messages from this method and/or from ConsoleController.move; it's up to you. -After each valid move, use the method TOAHModel.__str__ that we've provided to print a representation of the current state of the game. ''' instructions = input("In order to make a move, you must insert the \ initial_stool number and the final_stool number seperated by a comma. If you \ wish to exit the game, input 'exit' and answer'yes'. Press enter to begin!") prompt = input('Your move (initial_stool, final_stool):') while prompt != 'exit': new_list = prompt.split(sep=',') move_list = [] try: int(new_list[0]) or int(new_list[1]) except ValueError: print('Invalid entry! Try again') prompt = input('Your move (initial_stool, final_stool):') move_list.append(int(new_list[0])) move_list.append(int(new_list[1])) move(self.cheese_model, move_list[0], move_list[1]) print(self.cheese_model.__str__()) prompt = input('Your move (initial_stool, final_stool):') else: exit()
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. ''' model.move(origin, dest) print(model)
def move_four_stools(model: TOAHModel, n: int, source: int, intermediate1: int, intermediate2: int, destination: int): i = index_of_M(n) if n > 1: move_four_stools(model, n - i, source, destination, intermediate1, intermediate2) move_cheeses(model, i, source, intermediate1, destination) move_four_stools(model, n - i, intermediate2, source, intermediate1, destination) else: model.move(source, destination) if animate is True: print(model) time.sleep(delay)
def move_four_stools(model: TOAHModel, n: int, source: int, intermediate1: int, intermediate2: int, destination: int) -> None: """ Print moves to get n cheeses from source to destination, possibly using intermediates """ def M(n) -> int: """ return the minimum moves of moving n Cheeses on four stools >>> M(4) 9 """ if n == 1: return 1 else: moves = [] for i in range(1, n): moves.append(2 * M(n - i) + 2**i - 1) global mo mo = moves.copy() return min(moves) def find_i(n) -> int: """ return the index of a in the global variable mo >>> find_i(9) 1 """ return mo.index(n) def find(n): """ return the index of M(n) in the global variable mo + 1 since the index has a range from 1 to n(exclusive) >>>find(9) 3 """ return find_i(M(n)) + 1 if n > 1: move_four_stools(model, n - find(n), source, intermediate2, destination, intermediate1) move_three_stools(find(n), source, intermediate2, destination) move_four_stools(model, n - find(n), intermediate1, source, intermediate2, destination) else: model.move(source, destination)
def move(model: TOAHModel, origin: int, dest: int): ''' (TOAHModel, int, int) -> NoneType Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. REQ: 0 <= origin < self._number_of_stools REQ: 0 <= dest < self._number_of_stools ''' # Use the TOAHModel's move method to move the cheese model.move(origin, dest)
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. ''' if model.top_cheese[dest].size > model.top_cheese[origin].size: try: model.move(origin, dest) except IllegalMoveError(): print('You made a mistake, please try again')
def move(model: TOAHModel, origin: int, dest: int) -> None: ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. ''' try: model.move(origin, dest) except IllegalMoveError: print('Invalid move! Try again')
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float=0.5, console_animate: bool=False,): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to use ConsoleController to animate the tour delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ # store the number of cheeses in n, because it's shorter and easier n = model.number_of_cheeses() # create an empty list to store the moves (in tuple form) moves = [] # call the helper function so the solution can be stored in moves helper_four_stools(moves, n, 0, 1, 2, 3) # if user wants to animate if console_animate is True: # grab a movie one by one and apply it to the given model # until the moves list is empty while len(moves) != 0: # temp is basically the first move in the list # it's a tuple temp = moves[0] # delete that move from the original moves list because we # already saved it and we won't need it again moves = moves[1:] # since temp is a tuple, temp[0] is the original stool and # temp[1] is the destination stool: temp = (temp[0], temp[1]) model.move(temp[0], temp[1]) # if user wants a delay between moves, use sleep to pause time.sleep(delay_btw_moves) # print a visual representation of the model being changed print(model) # if user does not any animation, only the model is changed else: # exact same thing but this time there is no delay between moves while len(moves) != 0: # get origin stool temp = moves[0] # get destination stool moves = moves[1:] # change the model model.move(temp[0], temp[1])
class ConsoleController: def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ self.number_of_cheeses = number_of_cheeses self.number_of_stools = number_of_stools self.model = TOAHModel(number_of_stools) self.model.fill_first_stool(number_of_cheeses) def play_loop(self: 'ConsoleController'): ''' Console-based game. TODO: -Start by giving instructions about how to enter moves (which is up to you). Be sure to provide some way of exiting the game, and indicate that in the instructions. -Use python's built-in function input() to read a potential move from the user/player. You should print an error message if the input does not meet the specifications given in your instruction or if it denotes an invalid move (e.g. moving a cheese onto a smaller cheese). You can print error messages from this method and/or from ConsoleController.move; it's up to you. -After each valid move, use the method TOAHModel.__str__ that we've provided to print a representation of the current state of the game. ''' print('') print( 'Move the top cheese from the origin stool to the destination stool' ) print( 'by entering the number within the number of stools you have entered' ) print( '(number between 0 to the number of stools you entered before minus one' ) print('since the order of stools starts with 0)') print('') print(self.model) origin = int(input('Please enter the original stool: ')) dest = int(input('Please enter the destination stool: ')) move(self.model, origin, dest)
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. >>> M = TOAHModel(4) >>> M.fill_first_stool(1) >>> move(M, 0, 1) >>> M.get_stools() [[], [Cheese(1)], [], []] >>> M = TOAHModel(4) >>> M.fill_first_stool(4) >>> move(M, 0, 1) >>> move(M, 0, 2) >>> move(M, 1, 2) >>> M.get_stools() == [[Cheese(4), Cheese(3)], [], [Cheese(2),\ Cheese(1)], []] True >>> move(M, 2, 1) >>> M.get_stools() [[Cheese(4), Cheese(3)], [Cheese(1)], [Cheese(2)], []] >>> move(M, 0, 3) >>> M.get_stools() == [[Cheese(4)], [Cheese(1)], [Cheese(2)], \ [Cheese(3)]] True >>> move(M, 0, 1) Traceback (most recent call last): ... TOAHModel.IllegalMoveError: Cannot move bigger Cheese onto smaller Cheese >>> M = TOAHModel(4) >>> move(M, 0, 1) Traceback (most recent call last): ... TOAHModel.IllegalMoveError: This stool is empty! REQ: model.top_cheese(dest).size > model.top_cheese(origin).size ''' # Already implemented in TOAHModel. Better to simply use it. model.move(origin, dest)
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float=0.5, console_animate: bool=False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to animate the tour in the console delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ the_four_stools(model, model.number_of_cheeses(), 0, 1, 2, 3) # stool starts at 0 and ends at 3 if console_animate == True: x = model.get_move_seq() z = x.length() y = model.number_of_cheeses() model = TOAHModel(4) model.fill_first_stool(y) index = 0 time.sleep(delay_btw_moves) print(model) while index < z: time.sleep(delay_btw_moves) m = x.get_move(index) model.move(m[0],m[1]) time.sleep(delay_btw_moves) print(model) time.sleep(delay_btw_moves) index += 1
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float = 0.5, console_animate: bool = False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to use ConsoleController to animate the tour delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ # Call helper functions to move the cheese # If console_animate is true, print each step if (console_animate is True): # Pass true in the parameter to print four_stool_hanoi(model, model.number_of_cheeses(), 0, 1, 2, 3, True) # Otherwise don't print it else: four_stool_hanoi(model, model.number_of_cheeses(), 0, 1, 2, 3, False)
def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool, not counting the bottom cheese acting as stool number_of_stools - number of stools, to be shown as large cheeses """ # REPRESENTATION INVARIANT # self._number_of_cheeses is an integer which represents the number # of cheeses in the game # self._number_of_stools is an integer which represents the number # of stools in the game # self._model is a TOAHModel, which represents the game as a whole self._number_of_cheeses = number_of_cheeses self._number_of_stools = number_of_stools self._model = TOAHModel(self._number_of_stools) # Fill the first stool with the amount of cheese entered self._model.fill_first_stool(self._number_of_cheeses)
def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool, not counting the bottom cheese acting as stool number_of_stools - number of stools, to be shown as large cheeses """ self._model = TOAHModel(number_of_stools) self._model.fill_first_stool(number_of_cheeses)
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. ''' try: model.move(origin, dest) except IllegalMoveError: print ("***Can't perform move***") except IndexError: print ("***Stool does not exist***") except AttributeError: print ("***Move not possible***") else: pass
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float=0.5, console_animate: bool=False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to animate the tour in the console delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ four_hanoi(model.number_of_cheeses(), 0, 1, 2, 3, console_animate, delay_btw_moves)
def move(model: TOAHModel, origin: int, dest: int): ''' Module method to apply one move to the given model, and print any error message to the console. model - the TOAHModel that you want to modify origin - the stool number (indexing from 0!) of the cheese you want to move dest - the stool number that you want to move the top cheese on stool origin onto. ''' try: model.move(origin, dest) except IllegalMoveError: #This is so we can give the interface some "personality" rand = random.randint(1, 3) if rand == 1: print("Whoops! Can't do that!") elif rand == 2: print("Clearly someone needs to read the instructions again!") else: print("I can't let you do that.") except KeyError: print("That stool doesn't exist dummy.")
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float = 0.5, console_animate: bool = False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to animate the tour in the console delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ four_hanoi(model.number_of_cheeses(), 0, 1, 2, 3, console_animate, delay_btw_moves)
def play_loop(self: 'ConsoleController'): ''' Console-based game. TODO: -Start by giving instructions about how to enter moves (which is up to you). Be sure to provide some way of exiting the game, and indicate that in the instructions. -Use python's built-in function input() to read a potential move from the user/player. You should print an error message if the input does not meet the specifications given in your instruction or if it denotes an invalid move (e.g. moving a cheese onto a smaller cheese). You can print error messages from this method and/or from ConsoleController.move; it's up to you. -After each valid move, use the method TOAHModel.__str__ that we've provided to print a representation of the current state of the game. ''' m = TOAHModel(self.number_of_stools) m.fill_first_stool(self.number_of_cheeses) print("Then enter 2 integers sperated by a comma. first integer will be the stool to move the cheese from and second will be the stool the cheese has to be moved") print("Enter 'exit' to exit") s = input("Enter your move: ") while (s != "exit"): l=s.split(',') if len(l)==2: if not (l[0].isalpha() and l[1].isalpha()): move(m, int(l[0]),(int(l[1]))) # ask ta else: raise IllegalInputError("Not valid input") else: raise IllegalInputError("Not valid input") s=input("Enter the next move: ")
def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ # Initialize dict for converting the user command strings # to their methods self._cmd_to_method = { "MOVE": self.move, "HELP": self.help, "QUIT": self.quit, "EXIT": self.quit } # Create a TOAHModel with the specified number of stools self._model = TOAHModel(number_of_stools) # Put the TOAHModel in the starting config with the number of cheeses self._model.fill_first_stool(number_of_cheeses) return
def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int) -> None: """ Initialize a new 'ConsoleController'. """ TOAHModel.__init__(self, number_of_stools) TOAHModel.fill_first_stool(self, number_of_cheeses) self.cheese_model = TOAHModel(number_of_stools) self.number_of_stools = number_of_stools self.cheese_model.fill_first_stool(number_of_cheeses)
def tour_of_four_stools(model: 'TOAHModel', delay_btw_moves: float = 0.5, console_animate: bool = False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to animate the tour in the console delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False >>> m = TOAHModel(4) >>> m.fill_first_stool(8) >>> tour_of_four_stools(m) >>> m.get_move_seq().length() 33 """ # Use helper function to solve the problem four_stool_move( model, model.number_of_cheeses(), SRC_INDEX, # src_stool DEST_INDEX, # dest_stool (TEMP0_INDEX, TEMP1_INDEX)) # temp_stools # If animation is requested if (console_animate): # Get the MoveSequence from model move_seq = model.get_move_seq() # Create and set up a new 4-stool TOAHModel to animate anim_model = TOAHModel(4) anim_model.fill_first_stool(model.number_of_cheeses()) # Print the initial state of anim_model print(anim_model) # Go through each move in move_seq for i in range(move_seq.length()): # Get the source and destination stool indices (src_stool, dest_stool) = move_seq.get_move(i) # Delay the next move time.sleep(delay_btw_moves) # Apply the move anim_model.move(src_stool, dest_stool) # Print the result print(anim_model) return
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float=0.5, console_animate: bool=False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to use ConsoleController to animate the tour delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ src = 0 spare_1 = 1 spare_2 = 2 dest = 3 num_cheeses = model.number_of_cheeses() rec_four_stools(model, num_cheeses, src, spare_1, spare_2, dest, delay_btw_moves, console_animate)
model = TOAHModel(4) model.fill_first_stool(y) index = 0 time.sleep(delay_btw_moves) print(model) while index < z: time.sleep(delay_btw_moves) m = x.get_move(index) model.move(m[0],m[1]) time.sleep(delay_btw_moves) print(model) time.sleep(delay_btw_moves) index += 1 if __name__ == '__main__': NUM_CHEESES = 9 DELAY_BETWEEN_MOVES = 0.5 CONSOLE_ANIMATE = True # DO NOT MODIFY THE CODE BELOW. four_stools = TOAHModel(4) four_stools.fill_first_stool(number_of_cheeses=NUM_CHEESES) tour_of_four_stools(four_stools, console_animate=CONSOLE_ANIMATE, delay_btw_moves=DELAY_BETWEEN_MOVES) print(four_stools.number_of_moves())
print('=========================================================================') print("However, please choose how many cheeses you want on your stool: ") how_many_cheeses = input() if how_many_cheeses == 'Finish': print('Thanks for playing! ') sys.exit('You have chosen to exit the program. Bye!') while how_many_cheeses.isdigit() == False or int(how_many_cheeses) <= 0: print("Please enter a numeral value that is greater than 0") how_many_cheeses = input() try: how_many_cheeses = int(how_many_cheeses) except: print('Bad input, try again!') how_many_cheeses = int(input()) c1 = ConsoleController(how_many_cheeses,4) m5 = TOAHModel(c1.number_of_stools) m5.fill_first_stool(c1.number_of_cheeses) c1.play_loop() print('======================================================================') print('Below are the moves you made:') print(m5.get_move_seq()) x = m5.get_move_seq() print("Total moves made: "+str(x.length())) print("Play again soon!") print('======================================================================')
class ConsoleController: def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ self.number_of_cheeses = number_of_cheeses self.number_of_stools = number_of_stools self.model = TOAHModel(number_of_stools) self.cheeses = self.model.fill_first_stool(number_of_cheeses) self.play_loop() def play_loop(self: 'ConsoleController'): ''' Console-based game. TODO: -Start by giving instructions about how to enter moves (which is up to you). Be sure to provide some way of exiting the game, and indicate that in the instructions. -Use python's built-in function input() to read a potential move from the user/player. You should print an error message if the input does not meet the specifications given in your instruction or if it denotes an invalid move (e.g. moving a cheese onto a smaller cheese). You can print error messages from this method and/or from ConsoleController.move; it's up to you. -After each valid move, use the method TOAHModel.__str__ that we've provided to print a representation of the current state of the game. ''' print ("Welcome to Towers Of Anne Hoy!") print ("Instructions: The stool numbers start from 0.") print ("Please enter the source stool when prompted.") print ("Source stool is the stool number to move the cheese from.") print ("Please enter the destination stool when prompted.") print ("Destination stool is the stool number to move the cheese to.") print ("Enter 'e' to exit.") print (" ") print (self.model) print (" ") print ("Let's start!") print (" ") while True: try: if self.model.end_game_stool == self.model.stool_lst[-1]: print ("GAME OVER!") raise SystemExit self.play_loop origin_stool = input("Please enter the source stool: ") if origin_stool == 'e': print ("***Thanks for playing!***") raise SystemExit dest_stool = input("Please enter the destination stool: ") if dest_stool == 'e': print ("***Thanks for playing!***") raise SystemExit move(self.model, int(origin_stool), int(dest_stool)) print (self.model) print ("Number of moves so far: " +str(self.model.number_of_moves())) print (" ") except ValueError: print ("***Bad input***")
class GUIController: def __init__(self: 'GUIController', number_of_cheeses: int, number_of_stools: int, content_width: float, content_height: float, cheese_scale: float): """ Initialize a new GUIView. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools content_width - width in pixels of the working area content_height - height in pixels of the working area cheese_scale - height in pixels for showing cheese thicknesses, and to scale cheese diameters """ self._model = TOAHModel(number_of_stools) self._stools = [] self._cheese_to_move = None self._blinking = False self._number_of_stools = number_of_stools self.cheese_scale = cheese_scale self.root = TI.Tk() canvas = TI.Canvas(self.root, background="blue", width=content_width, height=content_height) canvas.pack(expand=True, fill=TI.BOTH) self.moves_label = TI.Label(self.root) self.show_number_of_moves() self.moves_label.pack() # the dimensions of a stool are the same as a cheese that's # one size bigger than the biggest of the number_of_cheeses cheeses. for stool_ind in range(number_of_stools): width = self.cheese_scale * (number_of_cheeses + 1) x_cent = content_width * (stool_ind + 1) / (number_of_stools + 1.0) y_cent = content_height - cheese_scale / 2 stool = StoolView(width, lambda s: self.stoolClicked(s), canvas, self.cheese_scale, x_cent, y_cent) self._stools.append(stool) # Can't use self._model.fill_first_stool because we need to # use CheeseView objects instead of just Cheese objects. total_size = self.cheese_scale for sizeparam in range(1, number_of_cheeses + 1): size = (number_of_cheeses + 1 - sizeparam) width = self.cheese_scale * size x_cent = content_width / (number_of_stools + 1.0) y_cent = content_height - cheese_scale / 2 - total_size cheese = CheeseView(size, width, lambda c: self.cheeseClicked(c), canvas, self.cheese_scale, x_cent, y_cent) self._model.add(0, cheese) total_size += self.cheese_scale def cheeseClicked(self: 'GUIController', cheese: 'CheeseView'): """React to cheese being clicked: if not in the middle of blinking then select cheese for moving, or for moving onto. cheese - clicked cheese """ if not self._blinking: self.select_cheese(cheese) def stoolClicked(self: 'GUIController', stool: 'StoolView'): """React to cheese being clicked: if not in the middle of blinking then select cheese for moving, or for moving onto. cheese - clicked cheese """ if not self._blinking: self.select_stool(stool) def select_cheese(self: 'GUIController', cheese: CheeseView): """ Called by cheeseClicked. If no cheese is selected to move, then select the cheese at top of clicked_cheese's stool (which may be clicked_cheese itself) and highlight it. If selected_cheese is already highlighted, then unhighlight it. Otherwise try to move self._cheese_to_move onto the stool that clicked_cheese is on. """ stool = self._stools[self._model.cheese_location(cheese)] stool_index = self.stool_index(stool) cheese = self._model.top_cheese(stool_index) #print(stool, stool_index, cheese) if self._cheese_to_move is None: self._cheese_to_move = cheese self._cheese_to_move.highlight(True) self.root.update() elif self._cheese_to_move is cheese: self._cheese_to_move.highlight(False) self._cheese_to_move = None self.root.update() else: self.select_platform_for_move(cheese, stool_index) def select_stool(self: 'GUIController', dest_stool: StoolView): """ Called by stoolClicked. Initiate a move if there is already some cheese highlighted (i.e. self._cheese_to_move is not None), unless self._cheese_to_move is on dest_stool, in which case do nothing. """ if self._cheese_to_move is not None: origin_stool = self._stools[self._model.cheese_location( self._cheese_to_move)] dest_stool_index = self.stool_index(dest_stool) origin_stool_index = self.stool_index(origin_stool) if origin_stool_index != dest_stool_index: top_cheese = self._model.top_cheese(dest_stool_index) if top_cheese is None: self.select_platform_for_move(dest_stool, dest_stool_index) else: self.select_platform_for_move(top_cheese, dest_stool_index) def select_platform_for_move(self: 'GUIController', platform: PlatformView, stool_index: int): """ Actually responsible for showing the cheese move on the screen, and for telling the model to update itself. Change self._cheese_to_move's coordinates so that it's on top of platform. platform - the StoolView or CheeseView that we want to move self._cheese_to_move onto. stool_index - if platform is a stool, then this is its index, and if platform is a cheese then this is the index of the stool that it is on. """ if self._cheese_to_move is not None: try: from_stool = self._model.cheese_location(self._cheese_to_move) self._model.move(from_stool, stool_index) self._cheese_to_move.place( platform.x_center, platform.y_center - self.cheese_scale) self.show_number_of_moves() except IllegalMoveError as e: print(e) self._blinking = True for i in range(10): self._cheese_to_move.highlight(i % 2 != 0) self.root.update() time.sleep(0.1) self._blinking = False self._cheese_to_move.highlight(False) self._cheese_to_move = None def stool_index(self: 'GUIView', stool: 'StoolView') -> int: return self._stools.index(stool) def show_number_of_moves(self: 'GUIView'): """Show the number of moves so far.""" self.moves_label.config(text='Number of moves: ' + str(self._model.number_of_moves())) def get_stool(self: 'GUIController', i: int) -> 'StoolView': return self._stools[i] def top_cheese(self: 'GUIController', i: int) -> 'CheeseView': return self._model.top_cheese(i)
class ConsoleController: def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools """ self.model = TOAHModel(number_of_stools) self.model.fill_first_stool(number_of_cheeses) self.has_seen_instructions = False def intro(self: 'ConsoleController') -> None: """ Simply prints an introduction to the console. """ print('--------------------------------------------------') print('| Welcome to the Towers of Anne Hoi game! |') print('| Can you move all of the cheeses? |') print("|Be careful though, you can't put a cheese on top|") print('| of a smaller cheese. |') print('| Good Luck! |') print('--------------------------------------------------') def display_instructions(self: 'ConsoleController'): """ Prints instructions to the console. """ print("Moves are entered in the following format:") print("'Location Stool' 'Destination Stool'") print("Separated by a space. ex. '1 2' moves the cheese") print("from the first stool to the second.") def process_query(self: "ConsoleController", query: str): """ Takes an input, and applies the appropriate command. """ #applies the move if it is indeed a move, or prints instructions #the only other valid command is exit which is accounted for in #play_loop if is_move(query): relocation = query.split() #I decided to make the first stool 1 instead of 0 #since it seems more intuitive to a user who doesn't #program. location = int(relocation[0]) - 1 destination = int(relocation[1]) - 1 move(self.model, location, destination) elif query.lower() == 'i': self.has_seen_instructions = False def play_loop(self: 'ConsoleController'): ''' Console-based game. TODO: -Start by giving instructions about how to enter moves (which is up to you). Be sure to provide some way of exiting the game, and indicate that in the instructions. -Use python's built-in function input() to read a potential move from the user/player. You should print an error message if the input does not meet the specifications given in your instruction or if it denotes an invalid move (e.g. moving a cheese onto a smaller cheese). You can print error messages from this method and/or from ConsoleController.move; it's up to you. -After each valid move, use the method TOAHModel.__str__ that we've provided to print a representation of the current state of the game. ''' self.intro() query = '' print(self.model) while not query.lower() == 'e': #So that we only see the instructions when wanted if not self.has_seen_instructions: self.display_instructions() self.has_seen_instructions = True else: print(self.model) print("Type 'i' to see instructions again. 'e' to exit") query = input("Please enter a move:") self.process_query(query) print("Goodbye!")
class GUIController: def __init__(self: 'GUIController', number_of_cheeses: int, number_of_stools: int, content_width: float, content_height: float, cheese_scale: float): """ Initialize a new GUIView. number_of_cheeses - number of cheese to tower on the first stool number_of_stools - number of stools content_width - width in pixels of the working area content_height - height in pixels of the working area cheese_scale - height in pixels for showing cheese thicknesses, and to scale cheese diameters """ self._model = TOAHModel(number_of_stools) self._stools = [] self._cheese_to_move = None self._blinking = False self._number_of_stools = number_of_stools self.cheese_scale = cheese_scale self.root = TI.Tk() canvas = TI.Canvas(self.root, background="blue", width=content_width, height=content_height) canvas.pack(expand=True, fill=TI.BOTH) self.moves_label = TI.Label(self.root) self.show_number_of_moves() self.moves_label.pack() # the dimensions of a stool are the same as a cheese that's # one size bigger than the biggest of the number_of_cheeses cheeses. for stool_ind in range(number_of_stools): width = self.cheese_scale * (number_of_cheeses + 1) x_cent = content_width * (stool_ind + 1) / (number_of_stools + 1.0) y_cent = content_height - cheese_scale / 2 stool = StoolView(width, lambda s: self.stoolClicked(s), canvas, self.cheese_scale, x_cent, y_cent) self._stools.append(stool) # Can't use self._model.fill_first_stool because we need to # use CheeseView objects instead of just Cheese objects. total_size = self.cheese_scale for sizeparam in range(1, number_of_cheeses + 1): size = (number_of_cheeses + 1 - sizeparam) width = self.cheese_scale * size x_cent = content_width / (number_of_stools + 1.0) y_cent = content_height - cheese_scale / 2 - total_size cheese = CheeseView(size, width, lambda c: self.cheeseClicked(c), canvas, self.cheese_scale, x_cent, y_cent) self._model.add(0, cheese) total_size += self.cheese_scale def cheeseClicked(self: 'GUIController', cheese: 'CheeseView'): """React to cheese being clicked: if not in the middle of blinking then select cheese for moving, or for moving onto. cheese - clicked cheese """ if not self._blinking: self.select_cheese(cheese) def stoolClicked(self: 'GUIController', stool: 'StoolView'): """React to cheese being clicked: if not in the middle of blinking then select cheese for moving, or for moving onto. cheese - clicked cheese """ if not self._blinking: self.select_stool(stool) def select_cheese(self: 'GUIController', cheese: CheeseView): """ Called by cheeseClicked. If no cheese is selected to move, then select the cheese at top of clicked_cheese's stool (which may be clicked_cheese itself) and highlight it. If selected_cheese is already highlighted, then unhighlight it. Otherwise try to move self._cheese_to_move onto the stool that clicked_cheese is on. """ stool = self._stools[self._model.cheese_location(cheese)] stool_index = self.stool_index(stool) cheese = self._model.top_cheese(stool_index) #print(stool, stool_index, cheese) if self._cheese_to_move is None: self._cheese_to_move = cheese self._cheese_to_move.highlight(True) self.root.update() elif self._cheese_to_move is cheese: self._cheese_to_move.highlight(False) self._cheese_to_move = None self.root.update() else: self.select_platform_for_move(cheese, stool_index) def select_stool(self: 'GUIController', dest_stool: StoolView): """ Called by stoolClicked. Initiate a move if there is already some cheese highlighted (i.e. self._cheese_to_move is not None), unless self._cheese_to_move is on dest_stool, in which case do nothing. """ if self._cheese_to_move is not None: origin_stool = self._stools[ self._model.cheese_location(self._cheese_to_move)] dest_stool_index = self.stool_index(dest_stool) origin_stool_index = self.stool_index(origin_stool) if origin_stool_index != dest_stool_index: top_cheese = self._model.top_cheese(dest_stool_index) if top_cheese is None: self.select_platform_for_move(dest_stool, dest_stool_index) else: self.select_platform_for_move(top_cheese, dest_stool_index) def select_platform_for_move(self: 'GUIController', platform: PlatformView, stool_index: int): """ Actually responsible for showing the cheese move on the screen, and for telling the model to update itself. Change self._cheese_to_move's coordinates so that it's on top of platform. platform - the StoolView or CheeseView that we want to move self._cheese_to_move onto. stool_index - if platform is a stool, then this is its index, and if platform is a cheese then this is the index of the stool that it is on. """ if self._cheese_to_move is not None: try: from_stool = self._model.cheese_location( self._cheese_to_move) self._model.move(from_stool, stool_index) self._cheese_to_move.place(platform.x_center, platform.y_center - self.cheese_scale) self.show_number_of_moves() except IllegalMoveError as e: print(e) self._blinking = True for i in range(10): self._cheese_to_move.highlight(i % 2 != 0) self.root.update() time.sleep(0.1) self._blinking = False self._cheese_to_move.highlight(False) self._cheese_to_move = None self.root.update() def stool_index(self: 'GUIView', stool: 'StoolView') -> int: return self._stools.index(stool) def show_number_of_moves(self: 'GUIView'): """Show the number of moves so far.""" self.moves_label.config(text='Number of moves: ' + str(self._model.number_of_moves())) def get_stool(self: 'GUIController', i: int) -> 'StoolView': return self._stools[i] def top_cheese(self: 'GUIController', i: int) -> 'CheeseView': return self._model.top_cheese(i)
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float = 0.5, console_animate: bool = False) -> None: """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to animate the tour in the console delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ def move_three_stools(n: int, source: int, intermediate: int, destination: int) -> None: """ Print moves to get n cheeses from source to destination, possibly using intermediate """ if n > 1: move_three_stools(n - 1, source, destination, intermediate) move_three_stools(1, source, intermediate, destination) move_three_stools(n - 1, intermediate, source, destination) else: model.move(source, destination) def move_four_stools(model: TOAHModel, n: int, source: int, intermediate1: int, intermediate2: int, destination: int) -> None: """ Print moves to get n cheeses from source to destination, possibly using intermediates """ def M(n) -> int: """ return the minimum moves of moving n Cheeses on four stools >>> M(4) 9 """ if n == 1: return 1 else: moves = [] for i in range(1, n): moves.append(2 * M(n - i) + 2**i - 1) global mo mo = moves.copy() return min(moves) def find_i(n) -> int: """ return the index of a in the global variable mo >>> find_i(9) 1 """ return mo.index(n) def find(n): """ return the index of M(n) in the global variable mo + 1 since the index has a range from 1 to n(exclusive) >>>find(9) 3 """ return find_i(M(n)) + 1 if n > 1: move_four_stools(model, n - find(n), source, intermediate2, destination, intermediate1) move_three_stools(find(n), source, intermediate2, destination) move_four_stools(model, n - find(n), intermediate1, source, intermediate2, destination) else: model.move(source, destination) move_four_stools(model, NUM_CHEESES, 0, 1, 2, 3) model2 = TOAHModel(4) model2.fill_first_stool(NUM_CHEESES) print(model2) for moves in model.get_move_seq()._moves: if console_animate: time.sleep(delay_btw_moves) model2.move(moves[0], moves[1]) print(model2)
moves = MoveSequence([]) four_stool_solution(moves, cheese_num, 0, 1, 2, 3) #Then we apply it to our existing model, animating with delay if #requested. if console_animate: for move in moves._moves: print(model) model.move(move[0], move[1]) time.sleep(delay_btw_moves) print(model) else: for move in moves._moves: model.move(move[0], move[1]) if __name__ == '__main__': NUM_CHEESES = 25 DELAY_BETWEEN_MOVES = .1 CONSOLE_ANIMATE = True # DO NOT MODIFY THE CODE BELOW. four_stools = TOAHModel(4) four_stools.fill_first_stool(number_of_cheeses=NUM_CHEESES) tour_of_four_stools(four_stools, console_animate=CONSOLE_ANIMATE, delay_btw_moves=DELAY_BETWEEN_MOVES) print(four_stools.number_of_moves())
class ConsoleController: def __init__(self: 'ConsoleController', number_of_cheeses: int, number_of_stools: int): """ Initialize a new 'ConsoleController'. number_of_cheeses - number of cheese to tower on the first stool, not counting the bottom cheese acting as stool number_of_stools - number of stools, to be shown as large cheeses """ self._model = TOAHModel(number_of_stools) self._model.fill_first_stool(number_of_cheeses) def get_model(self): """ (ConsoleController) -> TOAHModel Return the TOAHModel of this game. """ return self._model def play_loop(self: 'ConsoleController'): ''' Console-based game. TODO: -Start by giving instructions about how to enter moves (which is up to you). Be sure to provide some way of exiting the game, and indicate that in the instructions. -Use python's built-in function input() to read a potential move from the user/player. You should print an error message if the input does not meet the specifications given in your instruction or if it denotes an invalid move (e.g. moving a cheese onto a smaller cheese). You can print error messages from this method and/or from ConsoleController.move; it's up to you. -After each valid move, use the method TOAHModel.__str__ that we've provded to print a representation of the current state of the game. ''' print(self.get_model()) print(INSTRUCTIONS) print(DASH_SEPARATOR) cmd = input("Please enter your command: ") while(cmd != "quit"): # parse the user input to get src and dest stool index # re-enter if InvalidInputError exception caught try: src, dest = _instruction_filter(cmd) except InvalidInputError: print("Invalid Input!\nPlease follow the instruction!") print(INSTRUCTIONS + "\n" + DASH_SEPARATOR) cmd = input("Please enter your command: ") continue # perform move operation, re-enter command if exception caught try: move(self.get_model(), src, dest) except IllegalMoveError: print("Illegal Move!\nPlease follow the instruction!") print(INSTRUCTIONS + "\n" + DASH_SEPARATOR) cmd = input("Please enter your command: ") continue print(self.get_model()) print(DASH_SEPARATOR) # check if the game is ended if (self._winning_check()): print("Congratulation!") cmd = "quit" else: cmd = input("Please enter your command: ") print("Thank you for playing.") def _winning_check(self): """ (ConsoleController) -> bool Return True if all cheeses are moved to the last stool. This represents the game is ended. """ last_stool = self.get_model().get_stool(-1) return len(last_stool) == self.get_model().number_of_cheeses()
def tour_of_four_stools(model: TOAHModel, delay_btw_moves: float=0.5, console_animate: bool=False): """Move a tower of cheeses from the first stool in model to the fourth. model - a TOAHModel with a tower of cheese on the first stool and three other empty stools console_animate - whether to use ConsoleController to animate the tour delay_btw_moves - time delay between moves in seconds IF console_animate == True no effect if console_animate == False """ src = 0 spare_1 = 1 spare_2 = 2 dest = 3 num_cheeses = model.number_of_cheeses() rec_four_stools(model, num_cheeses, src, spare_1, spare_2, dest, delay_btw_moves, console_animate) if __name__ == '__main__': # DO NOT MODIFY THE CODE BELOW. model = TOAHModel(4) model.fill_first_stool(number_of_cheeses=8) tour_of_four_stools(model, console_animate=True, delay_btw_moves=0.5) print(model.number_of_moves()) # some debug code below, don't forget to comment it # # print(model.get_move_seq().get_moves())