def run_championship(self):
"""
This method runs the grand championship match. Since this is a double
elimination tourney, the lower bracket champion has to win 2 times in
order to win the overall championship.
Arguments:
:param self: This tourney object
"""
# Get champs
upper = self.upper_bracket.player # pylint: disable=no-member
lower = self.lower_bracket.player # pylint: disable=no-member
print('Championship Match')
print('{} v. {}'.format(upper.name, lower.name))
print('Match 1')
print('---------------------------------')
cur_match = Match(upper, lower, self.wins_needed)
results = cur_match.play_match()
self.matches.append(cur_match)
print('{} wins the match in {} games!\n'.format(
results['winner'], results['games_played']))
winner = upper if results['winner'] == upper.name else lower
loser = lower if results['winner'] == upper.name else upper
loser.losses += 1
# If the upper lost, we need to play again
if (loser.name == upper.name):
print('\nMatch 2')
print('---------------------------------')
cur_match = Match(upper, lower, self.wins_needed)
results = cur_match.play_match()
self.matches.append(cur_match)
print('{} wins the match in {} games!\n'.format(
results['winner'], results['games_played']))
winner = upper if results['winner'] == upper.name else lower
loser = lower if results['winner'] == upper.name else upper
loser.losses += 1
# We can now crown the champion!
print('\n\n')
print('Grand Champion')
print('---------------------------------')
print('{}'.format(self.victory_screen(winner.name)))
def run_lower_bracket(self):
"""
This method runs through the upper bracket. This advances through each
stage and runs all matches required. Loses are done and winners advance
to the next stage. The winner of the lower bracket plays in the grand
championship.
Arguments:
:param self: This tourney
"""
# Lower brackets alternate between major and minor events. If
# applicable, we will do the minor for the stage (Stage 1 has
# no minor), then we will do the majors
stage_num = 1
while (stage_num <= self.stages):
print('Lower Stage {}'.format(stage_num))
print('---------------------------\n')
# If we are stage one, there is no minor
if (stage_num is not 1):
# Find the parents of all children nodes that need played
nodes = findall(self.lower_bracket,
filter_=lambda node: node.name ==
'Stage{}-Major-Sub'.format(stage_num))
num_match = 1
for node in nodes:
print(node)
player1, player2 = (x.player for x in node.children)
cur_match = Match(player1, player2, self.wins_needed)
print('Match {} - {} v. {}'.format(num_match, player1.name,
player2.name))
print('---------------------------------')
results = cur_match.play_match()
self.matches.append(cur_match)
print('{} wins the match in {} games!\n'.format(
results['winner'], results['games_played']))
# Resolve Match
node.contestant = results['winner']
node.player = player1 if results[
'winner'] == player1.name else player2
# The loser is done! No more advancement. Move on to the minors.
loser = player2 if results[
'winner'] == player1.name else player1
loser.losses += 1
# Now do the major
# Find the parents of all children nodes that need played
nodes = findall(self.lower_bracket,
filter_=lambda node: node.name in
('Stage{}-Major'.format(stage_num)))
num_match = 1
for node in nodes:
player1, player2 = (x.player for x in node.children)
cur_match = Match(player1, player2, self.wins_needed)
print('Match {} - {} v. {}'.format(num_match, player1.name,
player2.name))
print('---------------------------------')
results = cur_match.play_match()
self.matches.append(cur_match)
print('{} wins the match in {} games!\n'.format(
results['winner'], results['games_played']))
# Resolve Match
node.contestant = results['winner']
node.player = player1 if results[
'winner'] == player1.name else player2
# The loser is done! No more advancement. Move on to the minors.
loser = player2 if results[
'winner'] == player1.name else player1
loser.losses += 1
# At the end of the stage, print the bracket
stage_num += 1
self.print_lower_bracket()
# Done! Print the bracket
print('End of Lower Bracket')
print('---------------------------\n')
self.print_brackets()
def run_upper_bracket(self):
"""
This method runs through the upper bracket. This advances through each
stage and runs all matches required. Loses are demoted to the lower
bracket and winners continue to the next stage.
Arguments:
:param self: This tourney
"""
# Run through each stage and advance the winner as needed
stage_num = 1
while (stage_num <= self.stages):
print('Upper Stage {}'.format(stage_num))
print('---------------------------\n')
cur_stage = stage_num + 1
# Find the parents of all children nodes that need played
nodes = findall(self.upper_bracket,
filter_=lambda node: node.name in
('Stage{}'.format(cur_stage)))
num_match = 1
for node in nodes:
player1, player2 = (x.player for x in node.children)
cur_match = Match(player1, player2, self.wins_needed)
print('Match {} - {} v. {}'.format(num_match, player1.name,
player2.name))
print('---------------------------------')
results = cur_match.play_match()
self.matches.append(cur_match)
print('{} wins the match in {} games!\n'.format(
results['winner'], results['games_played']))
node.contestant = results['winner']
node.player = player1 if results[
'winner'] == player1.name else player2
# Move the loser down to the loser's bracket
loser = player2 if results[
'winner'] == player1.name else player1
loser.losses += 1
# First check to see if this is the last stage
#if(stage_num is self.stages):
# Since we are the last stage, we go to the minor of the previous stage
#lower = findall(self.lower_bracket, lambda node: node.name == 'Stage{}-Minor'.format(stage_num) and node.player is None)[0]
#lower.contestant = loser.name
#lower.player = loser
# If we are an odd stage, we move to the major loser branch, else the minor
#elif(stage_num % 2 is 1):
#lower = findall(self.lower_bracket, lambda node: node.name == 'Stage{}-Major-Sub'.format(stage_num) and node.player is None)[0]
#lower.contestant = loser.name
#lower.player = loser
#else:
#lower = findall(self.lower_bracket, lambda node: node.name == 'Stage{}-Minor'.format(stage_num) and node.player is None)[0]
#lower.contestant = loser.name
#lower.player = loser
if (stage_num is 1):
# Since we are the last stage, we go to the minor of the previous stage
lower = findall(
self.lower_bracket,
lambda node: node.name == 'Stage{}-Major-Sub'.format(
stage_num) and node.player is None)[0]
lower.contestant = loser.name
lower.player = loser
else:
lower = findall(
self.lower_bracket,
lambda node: node.name == 'Stage{}-Minor'.format(
stage_num) and node.player is None)[0]
lower.contestant = loser.name
lower.player = loser
num_match += 1
# Now that this stage is done, print the brackets!
stage_num += 1
self.print_upper_bracket()
# Done! Print the bracket
print('End of Upper Bracket')
print('---------------------------\n')
self.print_brackets()
