def do_import(self, args):
'''
import
import [file location] [file name]
Imports a file from a specified location and loads it, when no
arguments are supplied is uses a default file
written by Sean
'''
result = args.split(" ")
looks_good = False
if args == "":
looks_good = True
self._lm = self._fm.import_binary_league()
if len(result) == 2:
looks_good = True
self._lm = self._fm.import_binary_league(result[0], result[1])
if looks_good:
if self._lm is not None:
self.do_displayLeague(None)
else:
self._lm = LeagueModel()
self._vm.display("Filepath incorrect, please try again")
else:
self._vm.display(
"Incorrect syntax:" +
"\r" +
"import [file location] [file name]")
def __init__(self):
cmd.Cmd.__init__(self)
self.prompt = "=>>"
self.intro = "Welcome to Python Alley League Builder (to view help, " \
"type 'help'):"
self._lm = LeagueModel()
self._vm = ViewModel()
self._fm = FilerModule()
class Console(cmd.Cmd):
def __init__(self):
cmd.Cmd.__init__(self)
self.prompt = "=>>"
self.intro = "Welcome to Python Alley League Builder (to view help, " \
"type 'help'):"
self._lm = LeagueModel()
self._vm = ViewModel()
self._fm = FilerModule()
# Commands are below
def do_exit(self, args):
"""
exit
This command closes the program
"""
return -1
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_deleteLeague(self, args):
'''
deleteLeague
This command will delete the current league.
'''
if self._lm.get_current_league() == "":
print("There is no league to be deleted.")
return
try:
current_league_name = str(self._lm.get_current_league())
except AttributeError:
print("You do not have a league to delete")
return
"""
self.vm.display("You are about to delete the league, " +
current_league_name + ". Are you sure you wish to "
+ "do this? Press Y to delete and N to cancel")
print(ord('Y'))
while True:
key = ord(getch())
if key == '121' or key == '89':
self.lm.delete_league()
self.vm.display(current_league_name + " deleted!")
break
else:
self.vm.display("Your league has not been deleted")
break
"""
self._lm.delete_league()
self._vm.display(current_league_name + " deleted!")
def do_displayLeague(self, args):
'''
displayLeague
This command will display your current league. It will list the
current characters and their skills
'''
if self._lm.get_current_league() == "":
print("You need to create a league first before trying to display "
"a league.")
return
self._vm.create_heading(self._lm.get_current_league())
self._vm.display(self._vm.build_table(self._lm.export_league()))
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.")
def do_renameCharacter(self, args):
'''
renameCharacter [oldName] [newName]
Renames the character with a new name provided
Names must be one word with no spaces
'''
# > Error handling: need to check that the character exists in league
# > Error handling: need to check that the new name is not an empty
# string
result = args.split(" ")
# self.vm.display("Results: " + result[0] + " " + result[1])
league = self._lm.get_current_league()
if league == "":
print("You need to create a league first before trying to rename "
"one of its characters.")
return
character = league.find_character(result[0])
# try:
character.set_name(result[1])
# except
self._vm.display(result[0] + " has been renamed to " +
character.get_name())
def do_deleteCharacter(self, args):
'''
deleteCharacter [Character Name]
This command will delete the character
'''
league = self._lm.get_current_league()
if league == "":
print("You need to create a league first before trying to delete "
"one of its characters.")
return
character = league.find_character(args)
if character is not None:
league.remove_character(character)
else:
self._vm.display("'" + args + "' is not recorded as being in "
"the league. No character has "
"been deleted.")
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.")
# Two methods for replacing all of a character's abilities:
def do_replaceAllAbilities(self, args):
'''
replaceAllAbilities [Character Name] [new ability1] [new ability 2]
[new ability 3]
This command replaces all abilities on a character. You must have
created a character first.
'''
result = args.split(" ")
league = self._lm.get_current_league()
if league == "":
print("You need to create a league first before trying to "
"replace the abilities of one of its characters.")
return
character = league.find_character(result[0])
# Error handling:
if character is not None:
self.replace_all_abilities(result, character)
else:
print(
"Please include the name of a character who is in the league")
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.")
# Three methods involved in editing a character's skills:
def do_editSkills(self, args):
"""
edit_skills [Character Name] [Brawl] [Shoot] [Dodge] [Might] [Finesse]
[Cunning]
Edits the value for the skills of a character. You must already have
created the character. The value for every skill is required.
"""
result = args.split(" ")
league = self._lm.get_current_league()
if league == "":
print("You need to create a league first before trying to "
"replace the abilities of one of its characters.")
return
character = league.find_character(result[0])
if character is not None:
self.edit_skills_middle(result, character)
else:
print("Invalid character name entered. Please try again.")
def edit_skills_middle(self, result, character):
"""
Written by MH
This function will continue the process of checking whether a
character's skills can be modified
:param result: a list containing the user's input
:param character: the instance of character
:return:
"""
if len(result) == 7:
self.edit_skills_last(result, character)
else:
print("You have not entered enough data for all of the skills. "
"Please try again")
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 do_displayCharacter(self, args):
'''
displayCharacter [Character Name]
Displays all information for a given character
'''
if self._lm.get_current_league() == "":
print("You need to create a league first before trying to "
"view a character in a league.")
return
if args == "" or args is None:
print("You must type the name of the character you wish to " +
"display. Type help displayCharacter for more information")
else:
try:
result = self._vm.build_character_table(
self._lm.export_character(args))
self._vm.display(result)
except IndexError as e:
pass
except TypeError as e:
self._vm.display(e.__doc__) # .__repr__())
# except IndexError:
# self._vm.display("Index Error")
# except:
# print("Unable to find information for " + args + ", Are you sure"
# + " they exist?")
def do_import(self, args):
'''
import
import [file location] [file name]
Imports a file from a specified location and loads it, when no
arguments are supplied is uses a default file
written by Sean
'''
result = args.split(" ")
looks_good = False
if args == "":
looks_good = True
self._lm = self._fm.import_binary_league()
if len(result) == 2:
looks_good = True
self._lm = self._fm.import_binary_league(result[0], result[1])
if looks_good:
if self._lm is not None:
self.do_displayLeague(None)
else:
self._lm = LeagueModel()
self._vm.display("Filepath incorrect, please try again")
else:
self._vm.display(
"Incorrect syntax:" +
"\r" +
"import [file location] [file name]")
def do_save(self, args):
'''
save [file location] [file name]
Saves a file for the game, prepares it for import in the future.
If no arguments present, default file is used
'''
# written by Sean
if self._lm.get_current_league() == "":
print("No league to save. Please load or create a league first.")
return
result = args.split(" ")
if args == "":
self._fm.export_league_binary_to_fs(self._lm)
self._vm.display("Exported league to data.pickles")
if len(result) == 2:
self._fm.export_league_binary_to_fs(self._lm, result[0], result[1])
self._vm.display("Exported league to " + result[0] + "\\" +
result[1])
def default(self, line):
"""
Called on an input line when the command prefix is not recognized.
In that case we execute the line as Python code.
"""
try:
exec(line) in self._locals, self._globals
except Exception as e:
print(e.__class__, ":", e)