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_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.")