generated from mwc/lab_dice
fdcd5d5ae9
Checkpoint 2: My thinking was different in that I was trying to see what the code was doing instead of actually figuring out the correct syntax. It was definitely easier to think this way as I already knew the code worked. I will add docstrings in my future code for portions of the code that is confusing.
150 lines
5.1 KiB
Python
150 lines
5.1 KiB
Python
from die import Die
|
|
|
|
class Yahtzee:
|
|
"""A command-line Yahtzee game.
|
|
This version of Yahtzee is initialized with a list of goals.
|
|
"""
|
|
def __init__(self, goals):
|
|
self.score = 0
|
|
self.goals = goals
|
|
self.dice = [Die() for num in range(5)]
|
|
"""
|
|
Just sets up the class. __init__ is always the first thing needed.
|
|
"""
|
|
|
|
def play(self):
|
|
print("Welcome to Yachtzee!")
|
|
self.score = 0
|
|
for goal in self.goals:
|
|
goal.used = False
|
|
while self.count_unused_goals() > 0:
|
|
self.play_round()
|
|
print(f"Your final score was {self.score}")
|
|
"""
|
|
Runs the game. It tells you the final score of the game.
|
|
"""
|
|
|
|
def play_round(self):
|
|
print("=" * 80)
|
|
self.rolls_left = 3
|
|
for die in self.dice:
|
|
die.roll()
|
|
self.show_status()
|
|
goal = self.choose_goal()
|
|
goal.used = True
|
|
self.score += goal.score(self.dice)
|
|
"""
|
|
Uses the rolls left, rolls the dice, and shows the score. Used to further the game.
|
|
"""
|
|
|
|
def show_status(self):
|
|
dice = ', '.join([str(die) for die in self.dice])
|
|
print(f"Score: {self.score}. Rolls left: {self.rolls_left}. Dice: {dice}.")
|
|
"""
|
|
Shows the score and how many rolls of the dice you have left. Uses the score and rolls left.
|
|
"""
|
|
|
|
def choose_goal(self):
|
|
options = []
|
|
unused_goals = self.get_unused_goals()
|
|
for goal in unused_goals:
|
|
option = goal.prompt(self.dice)
|
|
options.append(option)
|
|
if self.rolls_left > 0:
|
|
options.append("Re-roll")
|
|
choice = self.get_choice(options)
|
|
if options[choice] == "Re-roll":
|
|
self.reroll()
|
|
self.show_status()
|
|
return self.choose_goal()
|
|
else:
|
|
return unused_goals[choice]
|
|
"""
|
|
Allows the player to choose how many dice to reroll. If there are more than 0 dice left to reroll, it gives the player the option to.
|
|
"""
|
|
|
|
def get_choice(self, options):
|
|
print("What would you like to do?")
|
|
for i, option in enumerate(options):
|
|
print(f"{i}. {option}")
|
|
choice = input("> ")
|
|
while not self.option_choice_is_valid(choice, options):
|
|
print("Sorry, that's not a valid choice.")
|
|
choice = input("> ")
|
|
return int(choice)
|
|
"""
|
|
It tells if you don't choose a possible choice. It is there so it is not just a blank screen.
|
|
"""
|
|
|
|
def option_choice_is_valid(self, choice, options):
|
|
if not choice.isdigit():
|
|
return False
|
|
if int(choice) < 0:
|
|
return False
|
|
if int(choice) >= len(options):
|
|
return False
|
|
return True
|
|
"""
|
|
It allows the program to work as it makes sure that the choice is valid. It will make sure the choice is a number and is inside the number in the list.
|
|
"""
|
|
|
|
def count_unused_goals(self):
|
|
return len(self.get_unused_goals())
|
|
"""
|
|
It counts the number of unused goals to further the game. It takes the length of the unused goals.
|
|
"""
|
|
|
|
def get_unused_goals(self):
|
|
unused_goals = []
|
|
for goal in self.goals:
|
|
if not goal.used:
|
|
unused_goals.append(goal)
|
|
return unused_goals
|
|
"""
|
|
Finds the rest of the unused goals not chosen so far. It will make a list of unused goals and add the unused ones to it.
|
|
"""
|
|
|
|
def reroll(self):
|
|
self.rolls_left -= 1
|
|
choices = self.get_reroll_choices()
|
|
dice_to_reroll = self.get_dice_to_reroll(choices)
|
|
for die in dice_to_reroll:
|
|
die.roll()
|
|
"""
|
|
Allows the player to reroll a dice if they choose to. It will remove 1 from rolls left and find the choices the player has and then will reroll.
|
|
"""
|
|
|
|
def get_dice_to_reroll(self, choice_ints):
|
|
dice_to_reroll = []
|
|
for die in self.dice:
|
|
if die.face in choice_ints:
|
|
choice_ints.remove(die.face)
|
|
dice_to_reroll.append(die)
|
|
return dice_to_reroll
|
|
"""
|
|
It will remove dies when necessary. It will use the empty list then remove some dies then append what is left and then reroll from there.
|
|
"""
|
|
|
|
def get_reroll_choices(self):
|
|
print("Which dice do you want to re-roll?")
|
|
choices = input("> ")
|
|
while not self.reroll_choices_are_valid(choices):
|
|
print("Please enter the numbers on dice you want to re-roll.")
|
|
choices = input("> ")
|
|
choice_ints = [int(digit) for digit in choices]
|
|
return choice_ints
|
|
"""
|
|
Asks the player which dice they want to reroll and if they do not give a possible choice, it will ask again. It uses the valid reroll choices and returns a number called choice ints.
|
|
"""
|
|
|
|
def reroll_choices_are_valid(self, choices_str):
|
|
if not choices_str.isdigit():
|
|
return False
|
|
choice_ints = [int(digit) for digit in choices_str]
|
|
for die in self.dice:
|
|
if die.face in choice_ints:
|
|
choice_ints.remove(die.face)
|
|
return len(choice_ints) == 0
|
|
"""
|
|
Is used when the reroll choice is valid and will go until there are no more choices left. It will remove the unneeded dice faces and stop when there are no choices left.
|
|
""" |