def do_createLeague(self, args):
'''
createLeague [LeagueName]
This command creates a league with the given name. You must create
a league before you are able to add characters to it.
'''
if self._lm.get_current_league() != "":
print("The " + self._lm.get_current_league().get_name() +
" league is currently loaded. To create a new league, "
"please remove this one first.")
return
input_v = InputView()
result = args.split(' ')
if len(result) > 1:
self._vm.display("You have entered too many arguments. Please try "
"again")
return
try:
self._lm.set_abilities_file(self._fm.read_file("abilities.txt"))
# change to handle file systems
if args != "":
input_v.check_valid_name(args)
self._lm.add_league(args)
self._vm.display(args + " created")
else:
print("The new league must have a name!")
except InputException:
self._vm.display("Invalid name entry: use only alphanumeric "
"characters when naming a league. Please try "
"again")
except TypeError as e:
print("Please check your filesystem has all the necessary files.")
def do_renameLeague(self, args):
"""
renameLeague [new league name]
This command allows you to change the name of the current league.
"""
"""
if self._lm.get_current_league() == "":
print("You need to create a league first before trying to display "
"a league.")
return
"""
inputV = InputView()
result = args.split(" ")
# -MS-
if args == "":
self._vm.display("You must type a new name to replace the old")
elif len(result) > 1:
self._vm.display("You have entered too many arguments. Please try "
"again")
else:
try:
inputV.check_valid_name(result[0])
self._lm.get_current_league().set_name(result[0])
self._vm.display("The league is now named: " +
self._lm.get_current_league().get_name())
except InputException:
self._vm.display("Invalid name entry: use only alphanumeric "
"characters when renaming a league. Please "
"try again")
except AttributeError:
self._vm.display("There is no league to rename. I suggest " +
"you create one")
return
except Exception as e:
self._vm.display("You may not rename the league. " + str(e))
return
def do_replaceAbility(self, args):
'''
replaceAbility [Character Name] [Old Ability] [New Ability]
This command replaces an ability on a character that has already
been created.
'''
league = self._lm.get_current_league()
if league == "":
print("You need to create a league first before trying to "
"replace the ability of one of its characters.")
return
result = args.split(" ")
if len(result) < 3:
print("Not enough arguments. Please try again")
return
# What if there are too many arguments ???
input_v = InputView()
character = league.find_character(result[0])
if character is not None:
try:
# Validate the input:
input_v.check_valid_ability(result[1],
self._lm.get_all_abilities())
input_v.check_valid_ability(result[2],
self._lm.get_all_abilities())
# Check the user does not already have that ability:
abilities_list = character.get_abilities_names()
abilities_list.append(result[2])
input_v.check_duplicate_values(abilities_list)
character.replace_ability(character, result[1], result[2])
# print(result[0] + " has had the ability " + result[1] +
# " replaced with " + result[2])
except InputException as e:
print(e.value)
else:
print(result[0] + " is not in the " +
self._lm.get_current_league().get_name() + " league Please "
"try again.")
def __init__(self):
temp_names = []
while not self.__is_valid(temp_names):
temp_names = InputView.input_car_names().split(',')
self.__names = iter(temp_names)
def edit_skills_last(self, result, character):
"""
Written by MH
This function is the final method which checks whether a
character's skills can be modified
:param result: a list containing the user's input
:param character: the instance of character
:return:
"""
input_v = InputView()
try:
input_v.check_valid_skill_dice(result[1])
input_v.check_valid_skill_dice(result[2])
input_v.check_valid_skill_dice(result[3])
input_v.check_valid_skill_dice(result[4])
input_v.check_valid_skill_dice(result[5])
input_v.check_valid_skill_dice(result[6])
# Start with the first skill input data, not the name:
# remove the character name from the results list
# The result list will now be length 6
del result[0]
# Get the skills data from each of the args
num_dice_list = []
type_dice_list = []
for i in range(len(result)):
dice_str_data = \
Character.obtain_dice_data(result[i])
# print("number_dice_str: "+ number_dice_str)
# print("type_dice_str: " + type_dice_str)
num_dice_list.append(dice_str_data[0])
type_dice_list.append(dice_str_data[1])
try:
character.check_number_dice(character, num_dice_list)
try:
character.check_type_dice(character, type_dice_list)
# If the previous tests pass then the original skills
# can be removed and replaced with the updated skills:
skills_result = Character.obtain_dice_data(
result[0])
character.set_brawl(Skill(ESkill.brawl,
character.find_edice
(skills_result[1]),
skills_result[0]))
skills_result = Character.obtain_dice_data(
result[1])
character.set_shoot(Skill(ESkill.shoot,
character.find_edice
(skills_result[1]),
skills_result[0]))
skills_result = Character.obtain_dice_data(
result[2])
character.set_dodge(Skill(ESkill.dodge,
character.find_edice
(skills_result[1]),
skills_result[0]))
skills_result = Character.obtain_dice_data(
result[3])
character.set_might(Skill(ESkill.might,
character.find_edice
(skills_result[1]),
skills_result[0]))
skills_result = Character.obtain_dice_data(
result[4])
character.set_finesse(Skill(ESkill.finesse,
character.find_edice
(skills_result[1]),
skills_result[0]))
skills_result = Character.obtain_dice_data(
result[5])
character.set_cunning(Skill(ESkill.cunning,
character.find_edice
(skills_result[1]),
skills_result[0]))
print(character.get_name() + "'s skills have "
"successfuly been "
"replaced.")
except CharacterException as e:
print(e.value)
except CharacterException as e:
print(e.value)
except InputException as e:
print(e.value)
def replace_all_abilities(self, result, character):
"""
Written by MH
This method will check whether the character's abilities can be
replaced with new ones
:param result: a list con
:param character:
:return:
"""
input_v = InputView()
if len(result) == 1:
print("You have not set any abilities")
elif len(result) == 2:
try:
# Validate the input:
input_v.check_valid_ability(result[1],
self._lm.get_all_abilities())
character.check_abilities(character.get_name(),
character.__class__.__name__,
character.get_subclass_level
(character),
character.get_number_abilities(),
arg1=result[1])
# Delete the character's current abilities and set the new ones
character.clear_abilities()
character.set_abilities(arg1=result[1])
print("New abilities have been set for " +
character.get_name() + ": " +
character.get_abilities()[0].get_name())
except InputException as e:
print(e.value)
except CharacterException as e:
print(e.value)
elif len(result) == 3:
try:
# Validate the input:
input_v.check_valid_ability(result[1],
self._lm.get_all_abilities())
input_v.check_valid_ability(result[2],
self._lm.get_all_abilities())
character.check_abilities(character.get_name(),
character.__class__.__name__,
character.get_subclass_level
(character),
character.get_number_abilities(),
arg1=result[1], arg2=result[2])
# Check the user is not adding duplicate abilities:
abilities_list = character.get_abilities_names()
abilities_list.extend([result[1], result[2]])
input_v.check_duplicate_values(abilities_list)
# Delete the character's current abilities and set the new ones
character.clear_abilities()
character.set_abilities(arg1=result[1], arg2=result[2])
print("New abilities have been set for " +
character.get_name() + ": " +
character.get_abilities()[0].get_name() + " " +
character.get_abilities()[1].get_name())
except InputException as e:
print(e.value)
except CharacterException as e:
print(e.value)
elif len(result) == 4:
try:
# Validate the input:
input_v.check_valid_ability(result[1],
self._lm.get_all_abilities())
input_v.check_valid_ability(result[2],
self._lm.get_all_abilities())
input_v.check_valid_ability(result[3],
self._lm.get_all_abilities())
character.check_abilities(character.get_name(),
character.__class__.__name__,
character.get_subclass_level
(character),
character.get_number_abilities(),
arg1=result[1], arg2=result[2],
arg3=result[3])
# Check the user is not adding duplicate abilities:
abilities_list = character.get_abilities_names()
abilities_list.extend([result[1], result[2], result[3]])
input_v.check_duplicate_values(abilities_list)
# Delete the character's current abilities and set the new ones
character.clear_abilities()
character.set_abilities(arg1=result[1], arg2=result[2],
arg3=result[3])
print("New abilities have been set for " +
character.get_name() + ": " +
character.get_abilities()[0].get_name() + " " +
character.get_abilities()[1].get_name() + " " +
character.get_abilities()[2].get_name())
except InputException as e:
print(e.value)
except CharacterException as e:
print(e.value)
else:
print("You have entered too many arguments. Please try again.")
def do_addCharacter(self, args):
'''
addCharacter [CharacterName] [CharacterType] [Health] [Brawl] [Shoot]
[Dodge] [Might] [Finesse] [Cunning]
[Ability 1] [Ability 2] [Ability 3]
Example
addCharacter Testing Leader d10 3d8 3d10 3d10 2d8 3d10 2d10 Mighty
Brash Crafty
-----------------------------------------------------------------------
This command adds a character to the current league.
Your league starts with 10 roster slots.
-----------------------------------------------------------------------
[Character Name] = The character's name
[CharacterType] = Can be either 'Leader' 'SideKick' 'Ally' or
'Follower', You can only have ONE leader
Skills. See below for examples on how to use this argument
[Health] = A number used to represent your characters overall condition
[Brawl] = Represents a character's overall hand-to-hand combat prowess
[Shoot] = Indicates a character's combat effectiveness with all manner
of ranged weapons
[Dodge] = Determines the character's ability to avoid enemy attacks,
perils, and other dangers.
[Might] = Indicates a character's power, fitness and general
athleticism
[Finesse] = measures the character's co ordination, awareness and
ability to manipulate
[Cunning] = Represents a character's knowledge, resolve and ability to
solve complicated problems.
Skill levels by type
Leader
MUST have a health value of d10
Select four skills to start at 3 dice and two skills to start at
2 dice
Select four skills to start at d10 and two skills to start at d8
Can choose 3 abilities at any level
SideKick
MUST have a health value of d8
Select three skills to start at 3 dice and three skills to start at
2 dice
Select three skills to start at d8 and three skills to start at d6
Can choose 2 abilities at level 1 to 3
Uses three roster slots
Ally
MUST have a health value of d6
Select two skills to start at 2 dice and four skills to start at
1 dice
All skills start at d6
Can choose 1 ability at level 1 to 2
Uses two roster slots
Follower
MUST have a health value of d6
ALL skills must be 1d6
Can choose 1 ability at level 1
Uses one roster slot
'''
league = self._lm.get_current_league()
if league == "":
print("You need to create a league first before adding a "
"character.")
return
result = args.split(" ")
inputV = InputView()
if self._lm.get_current_league() is None:
print("You need to create a league first!")
return
if len(result) >= 10:
try:
inputV.check_valid_name(result[0])
inputV.check_valid_class(result[1])
inputV.check_valid_skill_dice(result[3])
inputV.check_valid_skill_dice(result[4])
inputV.check_valid_skill_dice(result[5])
inputV.check_valid_skill_dice(result[6])
inputV.check_valid_skill_dice(result[7])
inputV.check_valid_skill_dice(result[8])
all_abilities = self._lm.get_all_abilities()
if len(result) == 10:
try:
inputV.check_valid_ability(result[9], all_abilities)
league.add_character(name=result[0],
char_type=result[1],
health=result[2], brawl=result[3],
shoot=result[4], dodge=result[5],
might=result[
6], finesse=result[7],
cunning=result[8], arg1=result[9])
except InputException as e:
print(e.value)
elif len(result) == 11:
try:
inputV.check_valid_ability(result[9], all_abilities)
inputV.check_valid_ability(result[10], all_abilities)
inputV.check_duplicate_values([result[9], result[10]])
league.add_character(name=result[0],
char_type=result[1],
health=result[2], brawl=result[3],
shoot=result[4], dodge=result[5],
might=result[6],
finesse=result[7],
cunning=result[8], arg1=result[9],
arg2=result[10])
except InputException as e:
print(e.value)
elif len(result) == 12:
try:
inputV.check_valid_ability(result[9], all_abilities)
inputV.check_valid_ability(result[10], all_abilities)
inputV.check_valid_ability(result[11], all_abilities)
inputV.check_duplicate_values([result[9], result[10],
result[11]])
league.add_character(name=result[0],
char_type=result[1],
health=result[2], brawl=result[3],
shoot=result[4], dodge=result[5],
might=result[
6], finesse=result[7],
cunning=result[8], arg1=result[9],
arg2=result[10], arg3=result[11])
except InputException as e:
print(e.value)
else:
print("You have entered too many arguments. Please try "
"again.")
except InputException as e:
print(e.value)
else:
print("You have not entered enough arguments to create a character"
". Please try again.")